boss-css 0.0.1 → 0.0.3

package/dist/eslint-plugin/rules/no-unknown-classes.mjs

@@ -0,0 +1,119 @@
+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 { findInvalidTokens } from "../utils/boss-classes.mjs";
+
+//#region src/eslint-plugin/rules/no-unknown-classes.js
+const RULE_NAME = "no-unknown-classes";
+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 reportInvalid = (literal) => {
+		if (!literal || !literal.value) return;
+		const invalid = findInvalidTokens(literal.value, options);
+		if (!invalid.length) return;
+		const preview = invalid.slice(0, 3).join(", ");
+		const remainder = invalid.length > 3 ? ` (+${invalid.length - 3} more)` : "";
+		context.report({
+			node: literal.node,
+			messageId: "invalid",
+			data: { classes: preview + remainder }
+		});
+	};
+	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) reportInvalid(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) reportInvalid(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) reportInvalid(literal);
+		},
+		TaggedTemplateExpression(node) {
+			const tagName = getCalleeName(node.tag);
+			if (!tagName || !matchesPattern(patterns.tags, tagName)) return;
+			const literal = getLiteralInfo(node.quasi, sourceCode);
+			if (literal) reportInvalid(literal);
+		}
+	};
+};
+var no_unknown_classes_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow unknown or non-Boss 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: { invalid: "Invalid Boss class names: {{classes}}." }
+	},
+	create
+};
+
+//#endregion
+export { no_unknown_classes_default as default };

package/dist/eslint-plugin/rules/prefer-classnames.cjs

@@ -0,0 +1,69 @@
+const require_ast = require('../utils/ast.cjs');
+const require_defaults = require('../utils/defaults.cjs');
+const require_boss_classes = require('../utils/boss-classes.cjs');
+const require_static = require('../utils/static.cjs');
+
+//#region src/eslint-plugin/rules/prefer-classnames.js
+const RULE_NAME = "prefer-classnames";
+const defaultOptions = {
+	components: require_defaults.DEFAULT_COMPONENTS,
+	additionalContexts: [],
+	additionalProps: []
+};
+const isStyleProp = (name, options) => {
+	if (!name || name === "className" || name === "class") return false;
+	if (require_boss_classes.getContextSet(options).has(name)) return true;
+	return require_boss_classes.isCssPropName(name, options.additionalProps?.length ? new Set(options.additionalProps) : null);
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	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 || !isStyleProp(name, options)) continue;
+			if (!require_static.isStaticValue(attribute.value)) continue;
+			context.report({
+				node: attribute,
+				messageId: "preferClassnames",
+				data: { prop: name }
+			});
+		}
+	} };
+};
+var prefer_classnames_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer className for static Boss props; allow props for dynamic values only." },
+		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: { preferClassnames: "Use className instead of the static \"{{prop}}\" Boss prop." }
+	},
+	create
+};
+
+//#endregion
+exports.default = prefer_classnames_default;

package/dist/eslint-plugin/rules/prefer-classnames.mjs

@@ -0,0 +1,69 @@
+import { getJSXAttributeName, getJSXRootName } from "../utils/ast.mjs";
+import { DEFAULT_COMPONENTS } from "../utils/defaults.mjs";
+import { getContextSet, isCssPropName } from "../utils/boss-classes.mjs";
+import { isStaticValue } from "../utils/static.mjs";
+
+//#region src/eslint-plugin/rules/prefer-classnames.js
+const RULE_NAME = "prefer-classnames";
+const defaultOptions = {
+	components: DEFAULT_COMPONENTS,
+	additionalContexts: [],
+	additionalProps: []
+};
+const isStyleProp = (name, options) => {
+	if (!name || name === "className" || name === "class") return false;
+	if (getContextSet(options).has(name)) return true;
+	return isCssPropName(name, options.additionalProps?.length ? new Set(options.additionalProps) : null);
+};
+const create = (context) => {
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const componentSet = new Set(options.components);
+	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 || !isStyleProp(name, options)) continue;
+			if (!isStaticValue(attribute.value)) continue;
+			context.report({
+				node: attribute,
+				messageId: "preferClassnames",
+				data: { prop: name }
+			});
+		}
+	} };
+};
+var prefer_classnames_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer className for static Boss props; allow props for dynamic values only." },
+		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: { preferClassnames: "Use className instead of the static \"{{prop}}\" Boss prop." }
+	},
+	create
+};
+
+//#endregion
+export { prefer_classnames_default as default };

package/dist/eslint-plugin/rules/prefer-token-values.cjs

@@ -0,0 +1,197 @@
+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');
+
+//#region src/eslint-plugin/rules/prefer-token-values.js
+const RULE_NAME = "prefer-token-values";
+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 getPropertyName = (node) => {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "StringLiteral") return node.value;
+	return null;
+};
+const getMemberPath = (node) => {
+	const resolved = unwrapExpression(node);
+	if (!resolved) return null;
+	if (resolved.type === "CallExpression") return getMemberPath(resolved.callee);
+	if (resolved.type !== "MemberExpression" && resolved.type !== "OptionalMemberExpression") return null;
+	const parts = [];
+	let current = resolved;
+	while (current) {
+		if (current.type === "MemberExpression" || current.type === "OptionalMemberExpression") {
+			const propName = getPropertyName(current.property);
+			if (!propName) return null;
+			parts.unshift(propName);
+			current = unwrapExpression(current.object);
+			continue;
+		}
+		if (current.type === "Identifier") {
+			parts.unshift(current.name);
+			break;
+		}
+		return null;
+	}
+	return parts;
+};
+const getTokenPathFromNode = (node, sourceCode) => {
+	const resolved = unwrapExpression(node);
+	if (!resolved) return null;
+	const literalInfo = require_ast.getLiteralInfo(resolved, sourceCode);
+	if (literalInfo?.value && typeof literalInfo.value === "string") {
+		if (literalInfo.value.startsWith("$$.token.")) return literalInfo.value.slice(9);
+		return null;
+	}
+	const parts = getMemberPath(resolved);
+	if (!parts || parts.length < 3) return null;
+	if (parts[0] !== "$$" || parts[1] !== "token") return null;
+	return parts.slice(2).join(".");
+};
+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 dashToCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const getPropAliases = (api, name) => {
+	if (!name) return [];
+	const aliases = new Set([name]);
+	const dictionary = api?.dictionary;
+	if (dictionary) {
+		const entry = typeof dictionary.resolve === "function" && (dictionary.resolve(name).descriptor || dictionary.resolve(dashToCamelCase(name)).descriptor) || dictionary.get(name) || dictionary.get(dashToCamelCase(name));
+		if (entry?.property) aliases.add(entry.property);
+		if (Array.isArray(entry?.aliases)) entry.aliases.forEach((alias) => aliases.add(alias));
+	}
+	return Array.from(aliases);
+};
+const resolveTokenValue = (groupValues, tokenPath) => {
+	let current = groupValues;
+	for (const key of tokenPath) {
+		if (!current || typeof current !== "object") return void 0;
+		const next = current[key];
+		current = next && typeof next === "object" && "value" in next ? next.value : next;
+	}
+	return current;
+};
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	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();
+	const tokenGroups = api?.tokens && typeof api.tokens === "object" ? api.tokens : null;
+	if (!api || !tokenGroups) return {};
+	const reportTokenUsage = (node, propName, tokenKey) => {
+		context.report({
+			node,
+			messageId: "preferTokenValues",
+			data: {
+				prop: propName,
+				token: tokenKey
+			}
+		});
+	};
+	const checkValue = (valueNode, propName) => {
+		if (!valueNode) return;
+		const tokenPath = getTokenPathFromNode(valueNode, sourceCode);
+		if (!tokenPath) return;
+		const [groupName, ...rest] = tokenPath.split(".");
+		if (!groupName || rest.length === 0) return;
+		if (!getPropAliases(api, propName).includes(groupName)) return;
+		const groupValues = tokenGroups[groupName];
+		if (!groupValues) return;
+		if (resolveTokenValue(groupValues, rest) === void 0) return;
+		reportTokenUsage(valueNode, propName, rest.join("."));
+	};
+	const checkObjectExpression = (objectExpression) => {
+		for (const property of objectExpression.properties || []) {
+			if (!property || property.type !== "Property") continue;
+			if (property.kind && property.kind !== "init") continue;
+			if (property.computed) continue;
+			const key = getPropertyName(property.key);
+			if (!key) continue;
+			const value = property.value;
+			const resolved = unwrapExpression(value);
+			if (require_boss_classes.isCssPropName(key, extraProps)) {
+				checkValue(value, key);
+				continue;
+			}
+			if (resolved?.type === "ObjectExpression" && isContextKey(key, contextSet)) {
+				checkObjectExpression(resolved);
+				continue;
+			}
+			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 prefer_token_values_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer token keys instead of $$.token proxies when the prop has tokens." },
+		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: { preferTokenValues: "Use {{prop}}=\"{{token}}\" instead of $$.token for this prop." }
+	},
+	create
+};
+
+//#endregion
+exports.default = prefer_token_values_default;

package/dist/eslint-plugin/rules/prefer-token-values.mjs

@@ -0,0 +1,197 @@
+import { getJSXAttributeName, getJSXRootName, getLiteralInfo } 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";
+
+//#region src/eslint-plugin/rules/prefer-token-values.js
+const RULE_NAME = "prefer-token-values";
+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 getPropertyName = (node) => {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "StringLiteral") return node.value;
+	return null;
+};
+const getMemberPath = (node) => {
+	const resolved = unwrapExpression(node);
+	if (!resolved) return null;
+	if (resolved.type === "CallExpression") return getMemberPath(resolved.callee);
+	if (resolved.type !== "MemberExpression" && resolved.type !== "OptionalMemberExpression") return null;
+	const parts = [];
+	let current = resolved;
+	while (current) {
+		if (current.type === "MemberExpression" || current.type === "OptionalMemberExpression") {
+			const propName = getPropertyName(current.property);
+			if (!propName) return null;
+			parts.unshift(propName);
+			current = unwrapExpression(current.object);
+			continue;
+		}
+		if (current.type === "Identifier") {
+			parts.unshift(current.name);
+			break;
+		}
+		return null;
+	}
+	return parts;
+};
+const getTokenPathFromNode = (node, sourceCode) => {
+	const resolved = unwrapExpression(node);
+	if (!resolved) return null;
+	const literalInfo = getLiteralInfo(resolved, sourceCode);
+	if (literalInfo?.value && typeof literalInfo.value === "string") {
+		if (literalInfo.value.startsWith("$$.token.")) return literalInfo.value.slice(9);
+		return null;
+	}
+	const parts = getMemberPath(resolved);
+	if (!parts || parts.length < 3) return null;
+	if (parts[0] !== "$$" || parts[1] !== "token") return null;
+	return parts.slice(2).join(".");
+};
+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 dashToCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const getPropAliases = (api, name) => {
+	if (!name) return [];
+	const aliases = new Set([name]);
+	const dictionary = api?.dictionary;
+	if (dictionary) {
+		const entry = typeof dictionary.resolve === "function" && (dictionary.resolve(name).descriptor || dictionary.resolve(dashToCamelCase(name)).descriptor) || dictionary.get(name) || dictionary.get(dashToCamelCase(name));
+		if (entry?.property) aliases.add(entry.property);
+		if (Array.isArray(entry?.aliases)) entry.aliases.forEach((alias) => aliases.add(alias));
+	}
+	return Array.from(aliases);
+};
+const resolveTokenValue = (groupValues, tokenPath) => {
+	let current = groupValues;
+	for (const key of tokenPath) {
+		if (!current || typeof current !== "object") return void 0;
+		const next = current[key];
+		current = next && typeof next === "object" && "value" in next ? next.value : next;
+	}
+	return current;
+};
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	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();
+	const tokenGroups = api?.tokens && typeof api.tokens === "object" ? api.tokens : null;
+	if (!api || !tokenGroups) return {};
+	const reportTokenUsage = (node, propName, tokenKey) => {
+		context.report({
+			node,
+			messageId: "preferTokenValues",
+			data: {
+				prop: propName,
+				token: tokenKey
+			}
+		});
+	};
+	const checkValue = (valueNode, propName) => {
+		if (!valueNode) return;
+		const tokenPath = getTokenPathFromNode(valueNode, sourceCode);
+		if (!tokenPath) return;
+		const [groupName, ...rest] = tokenPath.split(".");
+		if (!groupName || rest.length === 0) return;
+		if (!getPropAliases(api, propName).includes(groupName)) return;
+		const groupValues = tokenGroups[groupName];
+		if (!groupValues) return;
+		if (resolveTokenValue(groupValues, rest) === void 0) return;
+		reportTokenUsage(valueNode, propName, rest.join("."));
+	};
+	const checkObjectExpression = (objectExpression) => {
+		for (const property of objectExpression.properties || []) {
+			if (!property || property.type !== "Property") continue;
+			if (property.kind && property.kind !== "init") continue;
+			if (property.computed) continue;
+			const key = getPropertyName(property.key);
+			if (!key) continue;
+			const value = property.value;
+			const resolved = unwrapExpression(value);
+			if (isCssPropName(key, extraProps)) {
+				checkValue(value, key);
+				continue;
+			}
+			if (resolved?.type === "ObjectExpression" && isContextKey(key, contextSet)) {
+				checkObjectExpression(resolved);
+				continue;
+			}
+			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 prefer_token_values_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer token keys instead of $$.token proxies when the prop has tokens." },
+		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: { preferTokenValues: "Use {{prop}}=\"{{token}}\" instead of $$.token for this prop." }
+	},
+	create
+};
+
+//#endregion
+export { prefer_token_values_default as default };