boss-css 0.0.1 → 0.0.3

package/dist/eslint-plugin/rules/props-only.cjs

@@ -0,0 +1,115 @@
+const require_ast = require('../utils/ast.cjs');
+const require_defaults = require('../utils/defaults.cjs');
+const require_boss_classes = require('../utils/boss-classes.cjs');
+
+//#region src/eslint-plugin/rules/props-only.js
+const RULE_NAME = "props-only";
+const defaultOptions = {
+	attributes: require_defaults.DEFAULT_ATTRIBUTE_PATTERNS,
+	callees: require_defaults.DEFAULT_CALLEE_PATTERNS,
+	variables: require_defaults.DEFAULT_VARIABLE_PATTERNS,
+	tags: require_defaults.DEFAULT_TAG_PATTERNS,
+	allowCustomContexts: false,
+	additionalContexts: [],
+	additionalProps: [],
+	singleProps: []
+};
+const createPatterns = (options) => ({
+	attributes: require_ast.compilePatterns(options.attributes),
+	callees: require_ast.compilePatterns(options.callees),
+	variables: require_ast.compilePatterns(options.variables),
+	tags: require_ast.compilePatterns(options.tags)
+});
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const patterns = createPatterns(options);
+	const reportLiteral = (literal) => {
+		if (!literal || !literal.value) return;
+		if (!require_boss_classes.containsBossToken(literal.value, options)) return;
+		context.report({
+			node: literal.node,
+			messageId: "propsOnly"
+		});
+	};
+	return {
+		JSXAttribute(node) {
+			const name = require_ast.getJSXAttributeName(node);
+			if (!name || !require_ast.matchesPattern(patterns.attributes, name)) return;
+			if (!node.value) return;
+			const literals = [];
+			require_ast.collectClassLiteralsFromExpression(node.value, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		CallExpression(node) {
+			const calleeName = require_ast.getCalleeName(node.callee);
+			if (!calleeName || !require_ast.matchesPattern(patterns.callees, calleeName)) return;
+			const literals = [];
+			for (const argument of node.arguments) require_ast.collectClassLiteralsFromExpression(argument, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		VariableDeclarator(node) {
+			if (!node.id || node.id.type !== "Identifier") return;
+			if (!require_ast.matchesPattern(patterns.variables, node.id.name)) return;
+			const literals = [];
+			require_ast.collectClassLiteralsFromExpression(node.init, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		TaggedTemplateExpression(node) {
+			const tagName = require_ast.getCalleeName(node.tag);
+			if (!tagName || !require_ast.matchesPattern(patterns.tags, tagName)) return;
+			const literal = require_ast.getLiteralInfo(node.quasi, sourceCode);
+			if (literal) reportLiteral(literal);
+		}
+	};
+};
+var props_only_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Require Boss style props instead of class names." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				attributes: {
+					type: "array",
+					items: { type: "string" }
+				},
+				callees: {
+					type: "array",
+					items: { type: "string" }
+				},
+				variables: {
+					type: "array",
+					items: { type: "string" }
+				},
+				tags: {
+					type: "array",
+					items: { type: "string" }
+				},
+				allowCustomContexts: { type: "boolean" },
+				additionalContexts: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				},
+				singleProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { propsOnly: "Use Boss props instead of class names for Boss styles." }
+	},
+	create
+};
+
+//#endregion
+exports.default = props_only_default;

package/dist/eslint-plugin/rules/props-only.mjs

@@ -0,0 +1,115 @@
+import { collectClassLiteralsFromExpression, compilePatterns, getCalleeName, getJSXAttributeName, getLiteralInfo, matchesPattern } from "../utils/ast.mjs";
+import { DEFAULT_ATTRIBUTE_PATTERNS, DEFAULT_CALLEE_PATTERNS, DEFAULT_TAG_PATTERNS, DEFAULT_VARIABLE_PATTERNS } from "../utils/defaults.mjs";
+import { containsBossToken } from "../utils/boss-classes.mjs";
+
+//#region src/eslint-plugin/rules/props-only.js
+const RULE_NAME = "props-only";
+const defaultOptions = {
+	attributes: DEFAULT_ATTRIBUTE_PATTERNS,
+	callees: DEFAULT_CALLEE_PATTERNS,
+	variables: DEFAULT_VARIABLE_PATTERNS,
+	tags: DEFAULT_TAG_PATTERNS,
+	allowCustomContexts: false,
+	additionalContexts: [],
+	additionalProps: [],
+	singleProps: []
+};
+const createPatterns = (options) => ({
+	attributes: compilePatterns(options.attributes),
+	callees: compilePatterns(options.callees),
+	variables: compilePatterns(options.variables),
+	tags: compilePatterns(options.tags)
+});
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const patterns = createPatterns(options);
+	const reportLiteral = (literal) => {
+		if (!literal || !literal.value) return;
+		if (!containsBossToken(literal.value, options)) return;
+		context.report({
+			node: literal.node,
+			messageId: "propsOnly"
+		});
+	};
+	return {
+		JSXAttribute(node) {
+			const name = getJSXAttributeName(node);
+			if (!name || !matchesPattern(patterns.attributes, name)) return;
+			if (!node.value) return;
+			const literals = [];
+			collectClassLiteralsFromExpression(node.value, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		CallExpression(node) {
+			const calleeName = getCalleeName(node.callee);
+			if (!calleeName || !matchesPattern(patterns.callees, calleeName)) return;
+			const literals = [];
+			for (const argument of node.arguments) collectClassLiteralsFromExpression(argument, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		VariableDeclarator(node) {
+			if (!node.id || node.id.type !== "Identifier") return;
+			if (!matchesPattern(patterns.variables, node.id.name)) return;
+			const literals = [];
+			collectClassLiteralsFromExpression(node.init, sourceCode, literals);
+			for (const literal of literals) reportLiteral(literal);
+		},
+		TaggedTemplateExpression(node) {
+			const tagName = getCalleeName(node.tag);
+			if (!tagName || !matchesPattern(patterns.tags, tagName)) return;
+			const literal = getLiteralInfo(node.quasi, sourceCode);
+			if (literal) reportLiteral(literal);
+		}
+	};
+};
+var props_only_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Require Boss style props instead of class names." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				attributes: {
+					type: "array",
+					items: { type: "string" }
+				},
+				callees: {
+					type: "array",
+					items: { type: "string" }
+				},
+				variables: {
+					type: "array",
+					items: { type: "string" }
+				},
+				tags: {
+					type: "array",
+					items: { type: "string" }
+				},
+				allowCustomContexts: { type: "boolean" },
+				additionalContexts: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				},
+				singleProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { propsOnly: "Use Boss props instead of class names for Boss styles." }
+	},
+	create
+};
+
+//#endregion
+export { props_only_default as default };

package/dist/eslint-plugin/rules/redundant-cx.cjs

@@ -0,0 +1,66 @@
+const require_ast = require('../utils/ast.cjs');
+const require_defaults = require('../utils/defaults.cjs');
+
+//#region src/eslint-plugin/rules/redundant-cx.js
+const RULE_NAME = "redundant-cx";
+const defaultOptions = {
+	components: require_defaults.DEFAULT_COMPONENTS,
+	callees: ["^cx$", "^\\$\\$\\.cx$"]
+};
+const getCallExpression = (node) => {
+	if (!node) return null;
+	if (node.type === "ChainExpression") return getCallExpression(node.expression);
+	if (node.type === "CallExpression") return node;
+	if (node.type === "OptionalCallExpression") return node;
+	return null;
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	const calleePatterns = require_ast.compilePatterns(options.callees);
+	return { JSXOpeningElement(node) {
+		const rootName = require_ast.getJSXRootName(node.name);
+		if (!rootName || !componentSet.has(rootName)) return;
+		for (const attribute of node.attributes) {
+			if (!attribute || attribute.type !== "JSXAttribute") continue;
+			if (require_ast.getJSXAttributeName(attribute) !== "className") continue;
+			const callExpression = getCallExpression(attribute.value?.type === "JSXExpressionContainer" ? attribute.value.expression : null);
+			if (!callExpression) continue;
+			const calleeName = require_ast.getCalleeName(callExpression.callee);
+			if (!calleeName || !require_ast.matchesPattern(calleePatterns, calleeName)) continue;
+			context.report({
+				node: attribute,
+				messageId: "redundantCx"
+			});
+		}
+	} };
+};
+var redundant_cx_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow wrapping $$ className with cx; $$ already applies cx semantics." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				components: {
+					type: "array",
+					items: { type: "string" }
+				},
+				callees: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { redundantCx: "Do not wrap $$ className with cx; pass values directly to className." }
+	},
+	create
+};
+
+//#endregion
+exports.default = redundant_cx_default;

package/dist/eslint-plugin/rules/redundant-cx.mjs

@@ -0,0 +1,66 @@
+import { compilePatterns, getCalleeName, getJSXAttributeName, getJSXRootName, matchesPattern } from "../utils/ast.mjs";
+import { DEFAULT_COMPONENTS } from "../utils/defaults.mjs";
+
+//#region src/eslint-plugin/rules/redundant-cx.js
+const RULE_NAME = "redundant-cx";
+const defaultOptions = {
+	components: DEFAULT_COMPONENTS,
+	callees: ["^cx$", "^\\$\\$\\.cx$"]
+};
+const getCallExpression = (node) => {
+	if (!node) return null;
+	if (node.type === "ChainExpression") return getCallExpression(node.expression);
+	if (node.type === "CallExpression") return node;
+	if (node.type === "OptionalCallExpression") return node;
+	return null;
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	const calleePatterns = compilePatterns(options.callees);
+	return { JSXOpeningElement(node) {
+		const rootName = getJSXRootName(node.name);
+		if (!rootName || !componentSet.has(rootName)) return;
+		for (const attribute of node.attributes) {
+			if (!attribute || attribute.type !== "JSXAttribute") continue;
+			if (getJSXAttributeName(attribute) !== "className") continue;
+			const callExpression = getCallExpression(attribute.value?.type === "JSXExpressionContainer" ? attribute.value.expression : null);
+			if (!callExpression) continue;
+			const calleeName = getCalleeName(callExpression.callee);
+			if (!calleeName || !matchesPattern(calleePatterns, calleeName)) continue;
+			context.report({
+				node: attribute,
+				messageId: "redundantCx"
+			});
+		}
+	} };
+};
+var redundant_cx_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow wrapping $$ className with cx; $$ already applies cx semantics." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				components: {
+					type: "array",
+					items: { type: "string" }
+				},
+				callees: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { redundantCx: "Do not wrap $$ className with cx; pass values directly to className." }
+	},
+	create
+};
+
+//#endregion
+export { redundant_cx_default as default };

package/dist/eslint-plugin/rules/require-prop-functions.cjs

@@ -0,0 +1,130 @@
+const require_ast = require('../utils/ast.cjs');
+const require_defaults = require('../utils/defaults.cjs');
+const require_api = require('../utils/api.cjs');
+const require_boss_classes = require('../utils/boss-classes.cjs');
+const require_static = require('../utils/static.cjs');
+
+//#region src/eslint-plugin/rules/require-prop-functions.js
+const RULE_NAME = "require-prop-functions";
+const defaultOptions = {
+	components: require_defaults.DEFAULT_COMPONENTS,
+	additionalContexts: [],
+	additionalProps: []
+};
+const unwrapExpression = (node) => {
+	if (!node) return node;
+	switch (node.type) {
+		case "JSXExpressionContainer": return unwrapExpression(node.expression);
+		case "ChainExpression": return unwrapExpression(node.expression);
+		case "ParenthesizedExpression": return unwrapExpression(node.expression);
+		case "TSAsExpression":
+		case "TSTypeAssertion":
+		case "TSNonNullExpression": return unwrapExpression(node.expression);
+		default: return node;
+	}
+};
+const isFunctionValue = (node) => {
+	const resolved = unwrapExpression(node);
+	return resolved?.type === "ArrowFunctionExpression" || resolved?.type === "FunctionExpression";
+};
+const getPropertyKey = (property) => {
+	const key = property.key;
+	if (!key) return null;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal") return `${key.value}`;
+	return null;
+};
+const isContainerContextKey = (name) => name === "container" || name.startsWith("container ") || name.startsWith("container_");
+const isContextKey = (name, contextSet) => {
+	if (!name) return false;
+	if (name.startsWith("[") && name.endsWith("]")) return true;
+	if (isContainerContextKey(name)) return true;
+	return contextSet.has(name);
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	const contextSet = require_boss_classes.getContextSet(options);
+	const extraProps = options.additionalProps?.length ? new Set(options.additionalProps) : null;
+	const { api } = require_api.getApi();
+	if (!Boolean(api?.plugins?.some?.((plugin) => plugin?.name === "classname-first"))) return {};
+	const reportDynamicValue = (node, propName) => {
+		context.report({
+			node,
+			messageId: "requirePropFunctions",
+			data: { prop: propName }
+		});
+	};
+	const checkValue = (valueNode, propName) => {
+		if (!valueNode) return;
+		if (require_static.isStaticValue(valueNode)) return;
+		if (isFunctionValue(valueNode)) return;
+		reportDynamicValue(valueNode, propName);
+	};
+	const checkObjectExpression = (objectExpression) => {
+		for (const property of objectExpression.properties || []) {
+			if (!property || property.type !== "Property") continue;
+			if (property.kind && property.kind !== "init") continue;
+			const propName = getPropertyKey(property);
+			if (!propName) continue;
+			const value = property.value;
+			if (require_boss_classes.isCssPropName(propName, extraProps)) {
+				checkValue(value, propName);
+				continue;
+			}
+			const resolved = unwrapExpression(value);
+			if (resolved?.type === "ObjectExpression" && isContextKey(propName, contextSet)) checkObjectExpression(resolved);
+			else if (resolved?.type === "ObjectExpression") checkObjectExpression(resolved);
+		}
+	};
+	return { JSXOpeningElement(node) {
+		const rootName = require_ast.getJSXRootName(node.name);
+		if (!rootName || !componentSet.has(rootName)) return;
+		for (const attribute of node.attributes) {
+			if (!attribute || attribute.type !== "JSXAttribute") continue;
+			const name = require_ast.getJSXAttributeName(attribute);
+			if (!name) continue;
+			if (name === "className" || name === "class") continue;
+			if (require_boss_classes.isCssPropName(name, extraProps)) {
+				checkValue(attribute.value, name);
+				continue;
+			}
+			if (!isContextKey(name, contextSet)) continue;
+			const value = unwrapExpression(attribute.value);
+			if (value?.type === "ObjectExpression") checkObjectExpression(value);
+		}
+	} };
+};
+var require_prop_functions_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Require dynamic Boss props to use functions when classname-first is enabled." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				components: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalContexts: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { requirePropFunctions: "Use {{prop}}={() => value} for dynamic Boss props with classname-first." }
+	},
+	create
+};
+
+//#endregion
+exports.default = require_prop_functions_default;

package/dist/eslint-plugin/rules/require-prop-functions.mjs

@@ -0,0 +1,130 @@
+import { getJSXAttributeName, getJSXRootName } from "../utils/ast.mjs";
+import { DEFAULT_COMPONENTS } from "../utils/defaults.mjs";
+import { getApi } from "../utils/api.mjs";
+import { getContextSet, isCssPropName } from "../utils/boss-classes.mjs";
+import { isStaticValue } from "../utils/static.mjs";
+
+//#region src/eslint-plugin/rules/require-prop-functions.js
+const RULE_NAME = "require-prop-functions";
+const defaultOptions = {
+	components: DEFAULT_COMPONENTS,
+	additionalContexts: [],
+	additionalProps: []
+};
+const unwrapExpression = (node) => {
+	if (!node) return node;
+	switch (node.type) {
+		case "JSXExpressionContainer": return unwrapExpression(node.expression);
+		case "ChainExpression": return unwrapExpression(node.expression);
+		case "ParenthesizedExpression": return unwrapExpression(node.expression);
+		case "TSAsExpression":
+		case "TSTypeAssertion":
+		case "TSNonNullExpression": return unwrapExpression(node.expression);
+		default: return node;
+	}
+};
+const isFunctionValue = (node) => {
+	const resolved = unwrapExpression(node);
+	return resolved?.type === "ArrowFunctionExpression" || resolved?.type === "FunctionExpression";
+};
+const getPropertyKey = (property) => {
+	const key = property.key;
+	if (!key) return null;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal") return `${key.value}`;
+	return null;
+};
+const isContainerContextKey = (name) => name === "container" || name.startsWith("container ") || name.startsWith("container_");
+const isContextKey = (name, contextSet) => {
+	if (!name) return false;
+	if (name.startsWith("[") && name.endsWith("]")) return true;
+	if (isContainerContextKey(name)) return true;
+	return contextSet.has(name);
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	const contextSet = getContextSet(options);
+	const extraProps = options.additionalProps?.length ? new Set(options.additionalProps) : null;
+	const { api } = getApi();
+	if (!Boolean(api?.plugins?.some?.((plugin) => plugin?.name === "classname-first"))) return {};
+	const reportDynamicValue = (node, propName) => {
+		context.report({
+			node,
+			messageId: "requirePropFunctions",
+			data: { prop: propName }
+		});
+	};
+	const checkValue = (valueNode, propName) => {
+		if (!valueNode) return;
+		if (isStaticValue(valueNode)) return;
+		if (isFunctionValue(valueNode)) return;
+		reportDynamicValue(valueNode, propName);
+	};
+	const checkObjectExpression = (objectExpression) => {
+		for (const property of objectExpression.properties || []) {
+			if (!property || property.type !== "Property") continue;
+			if (property.kind && property.kind !== "init") continue;
+			const propName = getPropertyKey(property);
+			if (!propName) continue;
+			const value = property.value;
+			if (isCssPropName(propName, extraProps)) {
+				checkValue(value, propName);
+				continue;
+			}
+			const resolved = unwrapExpression(value);
+			if (resolved?.type === "ObjectExpression" && isContextKey(propName, contextSet)) checkObjectExpression(resolved);
+			else if (resolved?.type === "ObjectExpression") checkObjectExpression(resolved);
+		}
+	};
+	return { JSXOpeningElement(node) {
+		const rootName = getJSXRootName(node.name);
+		if (!rootName || !componentSet.has(rootName)) return;
+		for (const attribute of node.attributes) {
+			if (!attribute || attribute.type !== "JSXAttribute") continue;
+			const name = getJSXAttributeName(attribute);
+			if (!name) continue;
+			if (name === "className" || name === "class") continue;
+			if (isCssPropName(name, extraProps)) {
+				checkValue(attribute.value, name);
+				continue;
+			}
+			if (!isContextKey(name, contextSet)) continue;
+			const value = unwrapExpression(attribute.value);
+			if (value?.type === "ObjectExpression") checkObjectExpression(value);
+		}
+	} };
+};
+var require_prop_functions_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Require dynamic Boss props to use functions when classname-first is enabled." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				components: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalContexts: {
+					type: "array",
+					items: { type: "string" }
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { requirePropFunctions: "Use {{prop}}={() => value} for dynamic Boss props with classname-first." }
+	},
+	create
+};
+
+//#endregion
+export { require_prop_functions_default as default };

package/dist/eslint-plugin/utils/api.cjs

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let boss_css_api_server = require("boss-css/api/server");
+let boss_css_api_config = require("boss-css/api/config");
+
+//#region src/eslint-plugin/utils/api.js
+let api = null;
+let error = null;
+let initPromise = null;
+const initApi = () => {
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		try {
+			api = await (0, boss_css_api_server.createApi)(await (0, boss_css_api_config.loadConfig)(process.cwd()), true);
+		} catch (err) {
+			error = err;
+		}
+	})();
+	return initPromise;
+};
+initApi();
+const getApi = () => {
+	if (!initPromise) initApi();
+	return {
+		api,
+		error
+	};
+};
+
+//#endregion
+exports.getApi = getApi;

package/dist/eslint-plugin/utils/api.mjs

@@ -0,0 +1,29 @@
+import { createApi } from "boss-css/api/server";
+import { loadConfig } from "boss-css/api/config";
+
+//#region src/eslint-plugin/utils/api.js
+let api = null;
+let error = null;
+let initPromise = null;
+const initApi = () => {
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		try {
+			api = await createApi(await loadConfig(process.cwd()), true);
+		} catch (err) {
+			error = err;
+		}
+	})();
+	return initPromise;
+};
+initApi();
+const getApi = () => {
+	if (!initPromise) initApi();
+	return {
+		api,
+		error
+	};
+};
+
+//#endregion
+export { getApi };