boss-css 0.0.1 → 0.0.2

package/dist/shared/customCss.cjs

@@ -0,0 +1,212 @@
+
+//#region src/shared/customCss.ts
+const isCssMemberExpression = (node) => {
+	if (!node || node.type !== "MemberExpression") return false;
+	if (node.object?.type !== "Identifier" || node.object.value !== "$$") return false;
+	const property = node.property;
+	if (property.type === "Identifier") return property.value === "css";
+	if (property.type === "StringLiteral") return property.value === "css";
+	return false;
+};
+const isCustomCssCall = (node) => {
+	return node.type === "CallExpression" && isCssMemberExpression(node.callee);
+};
+const isCustomCssTag = (node) => {
+	return node.type === "TaggedTemplateExpression" && isCssMemberExpression(node.tag);
+};
+const extractTemplateLiteral = (literal) => {
+	if (literal.expressions.length) return null;
+	const first = literal.quasis[0];
+	if (!first) return "";
+	return first.cooked ?? first.raw ?? "";
+};
+const parseStaticExpression = (expression) => {
+	if (!expression || typeof expression !== "object") return {
+		value: null,
+		dynamic: true
+	};
+	switch (expression.type) {
+		case "StringLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "NumericLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "BooleanLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "NullLiteral": return {
+			value: null,
+			dynamic: false
+		};
+		case "TemplateLiteral": {
+			const text = extractTemplateLiteral(expression);
+			if (text === null) return {
+				value: "",
+				dynamic: true
+			};
+			return {
+				value: text,
+				dynamic: false
+			};
+		}
+		case "ArrayExpression": return parseStaticArray(expression);
+		case "ObjectExpression": return parseStaticObject(expression);
+		case "UnaryExpression": return parseStaticUnary(expression);
+		case "ParenthesisExpression": return parseStaticExpression(expression.expression);
+		default: return {
+			value: null,
+			dynamic: true
+		};
+	}
+};
+const parseStaticArray = (expression) => {
+	const values = [];
+	let dynamic = false;
+	for (const entry of expression.elements) {
+		if (!entry || entry.expression == null) {
+			dynamic = true;
+			continue;
+		}
+		const parsed = parseStaticExpression(entry.expression);
+		dynamic ||= parsed.dynamic;
+		values.push(parsed.value);
+	}
+	return {
+		value: values,
+		dynamic
+	};
+};
+const parseStaticUnary = (expression) => {
+	if (expression.operator !== "-") return {
+		value: null,
+		dynamic: true
+	};
+	const parsed = parseStaticExpression(expression.argument);
+	if (parsed.dynamic || typeof parsed.value !== "number") return {
+		value: null,
+		dynamic: true
+	};
+	return {
+		value: -parsed.value,
+		dynamic: false
+	};
+};
+const parseStaticObject = (expression) => {
+	const value = {};
+	let dynamic = false;
+	for (const prop of expression.properties) {
+		if (prop.type !== "KeyValueProperty") {
+			dynamic = true;
+			continue;
+		}
+		const { key, value: propValue } = prop;
+		if (!key) {
+			dynamic = true;
+			continue;
+		}
+		let keyName = "";
+		switch (key.type) {
+			case "Identifier":
+				keyName = key.value;
+				break;
+			case "StringLiteral":
+				keyName = key.value;
+				break;
+			case "NumericLiteral":
+				keyName = String(key.value);
+				break;
+			case "BigIntLiteral":
+				keyName = String(key.value);
+				break;
+			default:
+				dynamic = true;
+				continue;
+		}
+		const parsed = parseStaticExpression(propValue);
+		dynamic ||= parsed.dynamic;
+		value[keyName] = parsed.value;
+	}
+	return {
+		value,
+		dynamic
+	};
+};
+const normalizePropertyName = (api, name) => {
+	if (name.startsWith("--")) return name;
+	return api.camelCaseToDash ? api.camelCaseToDash(name) : name;
+};
+const resolveNestedSelector = (parent, child) => {
+	if (!parent) return child;
+	if (child.includes("&")) return child.split("&").join(parent);
+	return `${parent} ${child}`;
+};
+const serializeCssObject = (api, value, selector = null) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+	const entries = Object.entries(value);
+	if (!entries.length) return "";
+	const declarations = [];
+	let nested = "";
+	for (const [key, entry] of entries) {
+		if (entry == null) continue;
+		if (typeof entry === "object" && !Array.isArray(entry)) {
+			if (key.startsWith("@")) {
+				const inner = serializeCssObject(api, entry, selector);
+				if (inner.trim()) nested += `${key} { ${inner} }`;
+			} else {
+				const inner = serializeCssObject(api, entry, resolveNestedSelector(selector, key));
+				if (inner.trim()) nested += inner;
+			}
+			continue;
+		}
+		const propertyName = normalizePropertyName(api, key);
+		const propertyValue = api.dictionary?.toValue ? api.dictionary.toValue(entry, propertyName) : entry;
+		declarations.push(`${propertyName}: ${propertyValue}`);
+	}
+	let output = "";
+	if (declarations.length) output += `${selector || ":root"} { ${declarations.join("; ")} }`;
+	if (nested.trim()) output += output ? `\n${nested}` : nested;
+	return output;
+};
+const extractCustomCssText = (expression, api) => {
+	if (isCustomCssTag(expression)) {
+		const raw = extractTemplateLiteral(expression.template);
+		if (raw === null) {
+			console.warn("[boss-css] $$.css template literals must be static (no expressions).");
+			return null;
+		}
+		return raw;
+	}
+	if (!isCustomCssCall(expression)) return null;
+	if (expression.arguments.length !== 1) {
+		console.warn("[boss-css] $$.css expects a single argument.");
+		return null;
+	}
+	const arg = expression.arguments[0]?.expression;
+	if (!arg) return null;
+	if (arg.type === "StringLiteral") return arg.value;
+	if (arg.type === "TemplateLiteral") {
+		const raw = extractTemplateLiteral(arg);
+		if (raw === null) {
+			console.warn("[boss-css] $$.css template literals must be static (no expressions).");
+			return null;
+		}
+		return raw;
+	}
+	if (arg.type === "ObjectExpression") {
+		const parsed = parseStaticObject(arg);
+		if (parsed.dynamic) {
+			console.warn("[boss-css] $$.css object arguments must be static.");
+			return null;
+		}
+		return serializeCssObject(api, parsed.value);
+	}
+	console.warn("[boss-css] $$.css only accepts string, template literal, or object arguments.");
+	return null;
+};
+
+//#endregion
+exports.extractCustomCssText = extractCustomCssText;

package/dist/shared/customCss.mjs

@@ -0,0 +1,211 @@
+//#region src/shared/customCss.ts
+const isCssMemberExpression = (node) => {
+	if (!node || node.type !== "MemberExpression") return false;
+	if (node.object?.type !== "Identifier" || node.object.value !== "$$") return false;
+	const property = node.property;
+	if (property.type === "Identifier") return property.value === "css";
+	if (property.type === "StringLiteral") return property.value === "css";
+	return false;
+};
+const isCustomCssCall = (node) => {
+	return node.type === "CallExpression" && isCssMemberExpression(node.callee);
+};
+const isCustomCssTag = (node) => {
+	return node.type === "TaggedTemplateExpression" && isCssMemberExpression(node.tag);
+};
+const extractTemplateLiteral = (literal) => {
+	if (literal.expressions.length) return null;
+	const first = literal.quasis[0];
+	if (!first) return "";
+	return first.cooked ?? first.raw ?? "";
+};
+const parseStaticExpression = (expression) => {
+	if (!expression || typeof expression !== "object") return {
+		value: null,
+		dynamic: true
+	};
+	switch (expression.type) {
+		case "StringLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "NumericLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "BooleanLiteral": return {
+			value: expression.value,
+			dynamic: false
+		};
+		case "NullLiteral": return {
+			value: null,
+			dynamic: false
+		};
+		case "TemplateLiteral": {
+			const text = extractTemplateLiteral(expression);
+			if (text === null) return {
+				value: "",
+				dynamic: true
+			};
+			return {
+				value: text,
+				dynamic: false
+			};
+		}
+		case "ArrayExpression": return parseStaticArray(expression);
+		case "ObjectExpression": return parseStaticObject(expression);
+		case "UnaryExpression": return parseStaticUnary(expression);
+		case "ParenthesisExpression": return parseStaticExpression(expression.expression);
+		default: return {
+			value: null,
+			dynamic: true
+		};
+	}
+};
+const parseStaticArray = (expression) => {
+	const values = [];
+	let dynamic = false;
+	for (const entry of expression.elements) {
+		if (!entry || entry.expression == null) {
+			dynamic = true;
+			continue;
+		}
+		const parsed = parseStaticExpression(entry.expression);
+		dynamic ||= parsed.dynamic;
+		values.push(parsed.value);
+	}
+	return {
+		value: values,
+		dynamic
+	};
+};
+const parseStaticUnary = (expression) => {
+	if (expression.operator !== "-") return {
+		value: null,
+		dynamic: true
+	};
+	const parsed = parseStaticExpression(expression.argument);
+	if (parsed.dynamic || typeof parsed.value !== "number") return {
+		value: null,
+		dynamic: true
+	};
+	return {
+		value: -parsed.value,
+		dynamic: false
+	};
+};
+const parseStaticObject = (expression) => {
+	const value = {};
+	let dynamic = false;
+	for (const prop of expression.properties) {
+		if (prop.type !== "KeyValueProperty") {
+			dynamic = true;
+			continue;
+		}
+		const { key, value: propValue } = prop;
+		if (!key) {
+			dynamic = true;
+			continue;
+		}
+		let keyName = "";
+		switch (key.type) {
+			case "Identifier":
+				keyName = key.value;
+				break;
+			case "StringLiteral":
+				keyName = key.value;
+				break;
+			case "NumericLiteral":
+				keyName = String(key.value);
+				break;
+			case "BigIntLiteral":
+				keyName = String(key.value);
+				break;
+			default:
+				dynamic = true;
+				continue;
+		}
+		const parsed = parseStaticExpression(propValue);
+		dynamic ||= parsed.dynamic;
+		value[keyName] = parsed.value;
+	}
+	return {
+		value,
+		dynamic
+	};
+};
+const normalizePropertyName = (api, name) => {
+	if (name.startsWith("--")) return name;
+	return api.camelCaseToDash ? api.camelCaseToDash(name) : name;
+};
+const resolveNestedSelector = (parent, child) => {
+	if (!parent) return child;
+	if (child.includes("&")) return child.split("&").join(parent);
+	return `${parent} ${child}`;
+};
+const serializeCssObject = (api, value, selector = null) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+	const entries = Object.entries(value);
+	if (!entries.length) return "";
+	const declarations = [];
+	let nested = "";
+	for (const [key, entry] of entries) {
+		if (entry == null) continue;
+		if (typeof entry === "object" && !Array.isArray(entry)) {
+			if (key.startsWith("@")) {
+				const inner = serializeCssObject(api, entry, selector);
+				if (inner.trim()) nested += `${key} { ${inner} }`;
+			} else {
+				const inner = serializeCssObject(api, entry, resolveNestedSelector(selector, key));
+				if (inner.trim()) nested += inner;
+			}
+			continue;
+		}
+		const propertyName = normalizePropertyName(api, key);
+		const propertyValue = api.dictionary?.toValue ? api.dictionary.toValue(entry, propertyName) : entry;
+		declarations.push(`${propertyName}: ${propertyValue}`);
+	}
+	let output = "";
+	if (declarations.length) output += `${selector || ":root"} { ${declarations.join("; ")} }`;
+	if (nested.trim()) output += output ? `\n${nested}` : nested;
+	return output;
+};
+const extractCustomCssText = (expression, api) => {
+	if (isCustomCssTag(expression)) {
+		const raw = extractTemplateLiteral(expression.template);
+		if (raw === null) {
+			console.warn("[boss-css] $$.css template literals must be static (no expressions).");
+			return null;
+		}
+		return raw;
+	}
+	if (!isCustomCssCall(expression)) return null;
+	if (expression.arguments.length !== 1) {
+		console.warn("[boss-css] $$.css expects a single argument.");
+		return null;
+	}
+	const arg = expression.arguments[0]?.expression;
+	if (!arg) return null;
+	if (arg.type === "StringLiteral") return arg.value;
+	if (arg.type === "TemplateLiteral") {
+		const raw = extractTemplateLiteral(arg);
+		if (raw === null) {
+			console.warn("[boss-css] $$.css template literals must be static (no expressions).");
+			return null;
+		}
+		return raw;
+	}
+	if (arg.type === "ObjectExpression") {
+		const parsed = parseStaticObject(arg);
+		if (parsed.dynamic) {
+			console.warn("[boss-css] $$.css object arguments must be static.");
+			return null;
+		}
+		return serializeCssObject(api, parsed.value);
+	}
+	console.warn("[boss-css] $$.css only accepts string, template literal, or object arguments.");
+	return null;
+};
+
+//#endregion
+export { extractCustomCssText };

package/dist/shared/debug.cjs

@@ -0,0 +1,76 @@
+
+//#region src/shared/debug.ts
+const truthyValues = new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+const falsyValues = new Set([
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+const normalizeDebugValue = (value) => {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value > 0;
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const lowered = trimmed.toLowerCase();
+	if (truthyValues.has(lowered)) return true;
+	if (falsyValues.has(lowered)) return false;
+	return trimmed;
+};
+const readLocalStorageDebug = () => {
+	if (typeof localStorage === "undefined") return void 0;
+	try {
+		return normalizeDebugValue(localStorage.getItem("BOSS_DEBUG"));
+	} catch {
+		return;
+	}
+};
+const readGlobalDebug = () => {
+	if (typeof globalThis === "undefined") return void 0;
+	return normalizeDebugValue(globalThis.BOSS_DEBUG);
+};
+const readEnvDebug = () => {
+	if (typeof process === "undefined" || !process.env) return void 0;
+	return normalizeDebugValue(process.env.BOSS_DEBUG);
+};
+const resolveDebugValue = (explicit) => {
+	if (explicit !== void 0) return explicit;
+	const fromStorage = readLocalStorageDebug();
+	if (fromStorage !== void 0) return fromStorage;
+	const fromGlobal = readGlobalDebug();
+	if (fromGlobal !== void 0) return fromGlobal;
+	return readEnvDebug();
+};
+const escapeRegexp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const createDebugMatcher = (debug) => {
+	if (debug === true) return () => true;
+	if (!debug || debug === false) return () => false;
+	const rawPatterns = debug.split(/[\s,]+/).map((pattern) => pattern.trim()).filter(Boolean);
+	if (!rawPatterns.length) return () => false;
+	const includes = [];
+	const excludes = [];
+	for (const pattern of rawPatterns) {
+		const isExclude = pattern.startsWith("-");
+		const raw = isExclude ? pattern.slice(1) : pattern;
+		if (!raw) continue;
+		const regex = /* @__PURE__ */ new RegExp(`^${escapeRegexp(raw).replace(/\\\*/g, ".*?")}$`);
+		if (isExclude) excludes.push(regex);
+		else includes.push(regex);
+	}
+	return (namespace) => {
+		if (excludes.some((regex) => regex.test(namespace))) return false;
+		if (!includes.length) return false;
+		return includes.some((regex) => regex.test(namespace));
+	};
+};
+
+//#endregion
+exports.createDebugMatcher = createDebugMatcher;
+exports.resolveDebugValue = resolveDebugValue;

package/dist/shared/debug.mjs

@@ -0,0 +1,74 @@
+//#region src/shared/debug.ts
+const truthyValues = new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+const falsyValues = new Set([
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+const normalizeDebugValue = (value) => {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value > 0;
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const lowered = trimmed.toLowerCase();
+	if (truthyValues.has(lowered)) return true;
+	if (falsyValues.has(lowered)) return false;
+	return trimmed;
+};
+const readLocalStorageDebug = () => {
+	if (typeof localStorage === "undefined") return void 0;
+	try {
+		return normalizeDebugValue(localStorage.getItem("BOSS_DEBUG"));
+	} catch {
+		return;
+	}
+};
+const readGlobalDebug = () => {
+	if (typeof globalThis === "undefined") return void 0;
+	return normalizeDebugValue(globalThis.BOSS_DEBUG);
+};
+const readEnvDebug = () => {
+	if (typeof process === "undefined" || !process.env) return void 0;
+	return normalizeDebugValue(process.env.BOSS_DEBUG);
+};
+const resolveDebugValue = (explicit) => {
+	if (explicit !== void 0) return explicit;
+	const fromStorage = readLocalStorageDebug();
+	if (fromStorage !== void 0) return fromStorage;
+	const fromGlobal = readGlobalDebug();
+	if (fromGlobal !== void 0) return fromGlobal;
+	return readEnvDebug();
+};
+const escapeRegexp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const createDebugMatcher = (debug) => {
+	if (debug === true) return () => true;
+	if (!debug || debug === false) return () => false;
+	const rawPatterns = debug.split(/[\s,]+/).map((pattern) => pattern.trim()).filter(Boolean);
+	if (!rawPatterns.length) return () => false;
+	const includes = [];
+	const excludes = [];
+	for (const pattern of rawPatterns) {
+		const isExclude = pattern.startsWith("-");
+		const raw = isExclude ? pattern.slice(1) : pattern;
+		if (!raw) continue;
+		const regex = /* @__PURE__ */ new RegExp(`^${escapeRegexp(raw).replace(/\\\*/g, ".*?")}$`);
+		if (isExclude) excludes.push(regex);
+		else includes.push(regex);
+	}
+	return (namespace) => {
+		if (excludes.some((regex) => regex.test(namespace))) return false;
+		if (!includes.length) return false;
+		return includes.some((regex) => regex.test(namespace));
+	};
+};
+
+//#endregion
+export { createDebugMatcher, resolveDebugValue };

package/dist/shared/file.cjs

@@ -0,0 +1,21 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let fast_glob = require("fast-glob");
+fast_glob = require_rolldown_runtime.__toESM(fast_glob);
+
+//#region src/shared/file.ts
+const DEFAULT_IGNORE = [
+	"**/node_modules/**",
+	"**/.bo$$/**",
+	"**/dist/**"
+];
+const resolveContentPaths = async (content) => {
+	return (0, fast_glob.default)(content, {
+		onlyFiles: false,
+		absolute: true,
+		cwd: process.cwd(),
+		ignore: DEFAULT_IGNORE
+	});
+};
+
+//#endregion
+exports.resolveContentPaths = resolveContentPaths;

package/dist/shared/file.mjs

@@ -0,0 +1,19 @@
+import fg from "fast-glob";
+
+//#region src/shared/file.ts
+const DEFAULT_IGNORE = [
+	"**/node_modules/**",
+	"**/.bo$$/**",
+	"**/dist/**"
+];
+const resolveContentPaths = async (content) => {
+	return fg(content, {
+		onlyFiles: false,
+		absolute: true,
+		cwd: process.cwd(),
+		ignore: DEFAULT_IGNORE
+	});
+};
+
+//#endregion
+export { resolveContentPaths };

package/dist/shared/framework.cjs

@@ -0,0 +1,10 @@
+
+//#region src/shared/framework.ts
+const getClassNameProp = (framework) => {
+	if (!framework || typeof framework === "string") return "className";
+	if ("className" in framework && framework.className) return framework.className;
+	return "className";
+};
+
+//#endregion
+exports.getClassNameProp = getClassNameProp;

package/dist/shared/framework.mjs

@@ -0,0 +1,9 @@
+//#region src/shared/framework.ts
+const getClassNameProp = (framework) => {
+	if (!framework || typeof framework === "string") return "className";
+	if ("className" in framework && framework.className) return framework.className;
+	return "className";
+};
+
+//#endregion
+export { getClassNameProp };

package/dist/shared/json.cjs

@@ -0,0 +1,58 @@
+
+//#region src/shared/json.ts
+const stripTrailingCommas = (input) => {
+	let output = "";
+	let inString = false;
+	let stringChar = "";
+	let escaped = false;
+	for (let index = 0; index < input.length; index += 1) {
+		const char = input[index];
+		if (inString) {
+			output += char;
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === stringChar) {
+				inString = false;
+				stringChar = "";
+			}
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			inString = true;
+			stringChar = char;
+			output += char;
+			continue;
+		}
+		if (char === ",") {
+			let lookahead = index + 1;
+			while (lookahead < input.length && /\s/.test(input[lookahead])) lookahead += 1;
+			const nextChar = input[lookahead];
+			if (nextChar === "}" || nextChar === "]") continue;
+		}
+		output += char;
+	}
+	return output;
+};
+const parseJson = (input, options) => {
+	try {
+		return JSON.parse(input);
+	} catch (error) {
+		if (!options?.allowTrailingCommas) throw error;
+		const stripped = stripTrailingCommas(input);
+		if (stripped !== input) try {
+			return JSON.parse(stripped);
+		} catch {}
+		const message = error instanceof Error ? error.message : String(error);
+		const fileHint = options?.filePath ? ` in ${options.filePath}` : "";
+		throw new Error(`Failed to parse JSON${fileHint}: ${message}`);
+	}
+};
+
+//#endregion
+exports.parseJson = parseJson;