boss-css 0.0.1 → 0.0.2

package/dist/dev/shared.cjs

@@ -0,0 +1,6 @@
+
+//#region src/dev/shared.ts
+const DEFAULT_DEV_PORT = 48400;
+
+//#endregion
+exports.DEFAULT_DEV_PORT = DEFAULT_DEV_PORT;

package/dist/dev/shared.mjs

@@ -0,0 +1,5 @@
+//#region src/dev/shared.ts
+const DEFAULT_DEV_PORT = 48400;
+
+//#endregion
+export { DEFAULT_DEV_PORT };

package/dist/eslint-plugin/index.cjs

@@ -0,0 +1,66 @@
+const require_format_classnames = require('./rules/format-classnames.cjs');
+const require_no_unknown_classes = require('./rules/no-unknown-classes.cjs');
+const require_props_only = require('./rules/props-only.cjs');
+const require_classnames_only = require('./rules/classnames-only.cjs');
+const require_prefer_classnames = require('./rules/prefer-classnames.cjs');
+const require_require_prop_functions = require('./rules/require-prop-functions.cjs');
+const require_redundant_cx = require('./rules/redundant-cx.cjs');
+const require_prefer_token_values = require('./rules/prefer-token-values.cjs');
+
+//#region src/eslint-plugin/index.js
+const plugin = {
+	meta: { name: "boss-css" },
+	rules: {
+		[require_format_classnames.default.name]: require_format_classnames.default,
+		[require_no_unknown_classes.default.name]: require_no_unknown_classes.default,
+		[require_props_only.default.name]: require_props_only.default,
+		[require_classnames_only.default.name]: require_classnames_only.default,
+		[require_prefer_classnames.default.name]: require_prefer_classnames.default,
+		[require_require_prop_functions.default.name]: require_require_prop_functions.default,
+		[require_redundant_cx.default.name]: require_redundant_cx.default,
+		[require_prefer_token_values.default.name]: require_prefer_token_values.default
+	}
+};
+const plugins = [plugin.meta.name];
+const globalOptions = { languageOptions: { globals: { $$: "readonly" } } };
+const createConfig = (name, getRules) => ({
+	[`${name}-error`]: {
+		plugins,
+		rules: getRules("error"),
+		...globalOptions
+	},
+	[`${name}-warn`]: {
+		plugins,
+		rules: getRules("warn"),
+		...globalOptions
+	},
+	[name]: {
+		plugins,
+		rules: getRules(),
+		...globalOptions
+	}
+});
+const getStylisticRules = (severity = "warn") => ({
+	[`${plugin.meta.name}/${require_format_classnames.default.name}`]: severity,
+	[`${plugin.meta.name}/${require_redundant_cx.default.name}`]: severity,
+	[`${plugin.meta.name}/${require_prefer_token_values.default.name}`]: severity
+});
+const getCorrectnessRules = (severity = "error") => ({
+	[`${plugin.meta.name}/${require_no_unknown_classes.default.name}`]: severity,
+	[`${plugin.meta.name}/${require_require_prop_functions.default.name}`]: severity
+});
+const config = {
+	...plugin,
+	configs: {
+		...createConfig("stylistic", getStylisticRules),
+		...createConfig("correctness", getCorrectnessRules),
+		...createConfig("recommended", (severity) => ({
+			...getStylisticRules(severity),
+			...getCorrectnessRules(severity)
+		}))
+	}
+};
+var eslint_plugin_default = config;
+
+//#endregion
+module.exports = eslint_plugin_default;

package/dist/eslint-plugin/index.mjs

@@ -0,0 +1,66 @@
+import format_classnames_default from "./rules/format-classnames.mjs";
+import no_unknown_classes_default from "./rules/no-unknown-classes.mjs";
+import props_only_default from "./rules/props-only.mjs";
+import classnames_only_default from "./rules/classnames-only.mjs";
+import prefer_classnames_default from "./rules/prefer-classnames.mjs";
+import require_prop_functions_default from "./rules/require-prop-functions.mjs";
+import redundant_cx_default from "./rules/redundant-cx.mjs";
+import prefer_token_values_default from "./rules/prefer-token-values.mjs";
+
+//#region src/eslint-plugin/index.js
+const plugin = {
+	meta: { name: "boss-css" },
+	rules: {
+		[format_classnames_default.name]: format_classnames_default,
+		[no_unknown_classes_default.name]: no_unknown_classes_default,
+		[props_only_default.name]: props_only_default,
+		[classnames_only_default.name]: classnames_only_default,
+		[prefer_classnames_default.name]: prefer_classnames_default,
+		[require_prop_functions_default.name]: require_prop_functions_default,
+		[redundant_cx_default.name]: redundant_cx_default,
+		[prefer_token_values_default.name]: prefer_token_values_default
+	}
+};
+const plugins = [plugin.meta.name];
+const globalOptions = { languageOptions: { globals: { $$: "readonly" } } };
+const createConfig = (name, getRules) => ({
+	[`${name}-error`]: {
+		plugins,
+		rules: getRules("error"),
+		...globalOptions
+	},
+	[`${name}-warn`]: {
+		plugins,
+		rules: getRules("warn"),
+		...globalOptions
+	},
+	[name]: {
+		plugins,
+		rules: getRules(),
+		...globalOptions
+	}
+});
+const getStylisticRules = (severity = "warn") => ({
+	[`${plugin.meta.name}/${format_classnames_default.name}`]: severity,
+	[`${plugin.meta.name}/${redundant_cx_default.name}`]: severity,
+	[`${plugin.meta.name}/${prefer_token_values_default.name}`]: severity
+});
+const getCorrectnessRules = (severity = "error") => ({
+	[`${plugin.meta.name}/${no_unknown_classes_default.name}`]: severity,
+	[`${plugin.meta.name}/${require_prop_functions_default.name}`]: severity
+});
+const config = {
+	...plugin,
+	configs: {
+		...createConfig("stylistic", getStylisticRules),
+		...createConfig("correctness", getCorrectnessRules),
+		...createConfig("recommended", (severity) => ({
+			...getStylisticRules(severity),
+			...getCorrectnessRules(severity)
+		}))
+	}
+};
+var eslint_plugin_default = config;
+
+//#endregion
+export { eslint_plugin_default as default };

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

@@ -0,0 +1,68 @@
+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/classnames-only.js
+const RULE_NAME = "classnames-only";
+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) continue;
+			if (!isStyleProp(name, options)) continue;
+			context.report({
+				node: attribute,
+				messageId: "classnamesOnly",
+				data: { prop: name }
+			});
+		}
+	} };
+};
+var classnames_only_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Boss style props; require className instead." },
+		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: { classnamesOnly: "Use className instead of the \"{{prop}}\" Boss prop." }
+	},
+	create
+};
+
+//#endregion
+exports.default = classnames_only_default;

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

@@ -0,0 +1,68 @@
+import { getJSXAttributeName, getJSXRootName } from "../utils/ast.mjs";
+import { DEFAULT_COMPONENTS } from "../utils/defaults.mjs";
+import { getContextSet, isCssPropName } from "../utils/boss-classes.mjs";
+
+//#region src/eslint-plugin/rules/classnames-only.js
+const RULE_NAME = "classnames-only";
+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) continue;
+			if (!isStyleProp(name, options)) continue;
+			context.report({
+				node: attribute,
+				messageId: "classnamesOnly",
+				data: { prop: name }
+			});
+		}
+	} };
+};
+var classnames_only_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Boss style props; require className instead." },
+		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: { classnamesOnly: "Use className instead of the \"{{prop}}\" Boss prop." }
+	},
+	create
+};
+
+//#endregion
+export { classnames_only_default as default };

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

@@ -0,0 +1,137 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_ast = require('../utils/ast.cjs');
+const require_defaults = require('../utils/defaults.cjs');
+const require_format = require('../utils/format.cjs');
+const require_boss_classes = require('../utils/boss-classes.cjs');
+const require_order = require('../utils/order.cjs');
+let boss_css_merge = require("boss-css/merge");
+
+//#region src/eslint-plugin/rules/format-classnames.js
+const RULE_NAME = "format-classnames";
+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,
+	merge: {},
+	order: "improved",
+	additionalProps: []
+};
+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 formatClassList = (merge, literal, options) => {
+	if (!literal.value) return null;
+	const next = require_order.sortTokens(require_boss_classes.splitClassList(merge(literal.value)), options).join(" ");
+	if (next === literal.value) return null;
+	return next;
+};
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const patterns = createPatterns(options);
+	const merge = (0, boss_css_merge.createBossMerge)(options.merge || {});
+	const reportLiteral = (literal) => {
+		if (!literal || !literal.canFix) return;
+		const next = formatClassList(merge, literal, options);
+		if (!next) return;
+		context.report({
+			node: literal.node,
+			messageId: "format",
+			data: {
+				original: literal.value,
+				formatted: next
+			},
+			fix: (fixer) => fixer.replaceText(literal.node, require_format.buildLiteralReplacement(literal.node, sourceCode, next))
+		});
+	};
+	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 format_classnames_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: { description: "Normalize Boss class lists using boss-css/merge." },
+		fixable: "code",
+		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" }
+				},
+				merge: {
+					type: "object",
+					additionalProperties: true
+				},
+				order: {
+					type: "string",
+					enum: [
+						"none",
+						"asc",
+						"desc",
+						"official",
+						"improved"
+					]
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { format: "Boss class list is not normalized." }
+	},
+	create
+};
+
+//#endregion
+exports.default = format_classnames_default;

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

@@ -0,0 +1,136 @@
+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 { buildLiteralReplacement } from "../utils/format.mjs";
+import { splitClassList } from "../utils/boss-classes.mjs";
+import { sortTokens } from "../utils/order.mjs";
+import { createBossMerge } from "boss-css/merge";
+
+//#region src/eslint-plugin/rules/format-classnames.js
+const RULE_NAME = "format-classnames";
+const defaultOptions = {
+	attributes: DEFAULT_ATTRIBUTE_PATTERNS,
+	callees: DEFAULT_CALLEE_PATTERNS,
+	variables: DEFAULT_VARIABLE_PATTERNS,
+	tags: DEFAULT_TAG_PATTERNS,
+	merge: {},
+	order: "improved",
+	additionalProps: []
+};
+const createPatterns = (options) => ({
+	attributes: compilePatterns(options.attributes),
+	callees: compilePatterns(options.callees),
+	variables: compilePatterns(options.variables),
+	tags: compilePatterns(options.tags)
+});
+const formatClassList = (merge, literal, options) => {
+	if (!literal.value) return null;
+	const next = sortTokens(splitClassList(merge(literal.value)), options).join(" ");
+	if (next === literal.value) return null;
+	return next;
+};
+const create = (context) => {
+	const sourceCode = context.getSourceCode();
+	const options = {
+		...defaultOptions,
+		...context.options[0] || {}
+	};
+	const patterns = createPatterns(options);
+	const merge = createBossMerge(options.merge || {});
+	const reportLiteral = (literal) => {
+		if (!literal || !literal.canFix) return;
+		const next = formatClassList(merge, literal, options);
+		if (!next) return;
+		context.report({
+			node: literal.node,
+			messageId: "format",
+			data: {
+				original: literal.value,
+				formatted: next
+			},
+			fix: (fixer) => fixer.replaceText(literal.node, buildLiteralReplacement(literal.node, sourceCode, next))
+		});
+	};
+	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 format_classnames_default = {
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: { description: "Normalize Boss class lists using boss-css/merge." },
+		fixable: "code",
+		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" }
+				},
+				merge: {
+					type: "object",
+					additionalProperties: true
+				},
+				order: {
+					type: "string",
+					enum: [
+						"none",
+						"asc",
+						"desc",
+						"official",
+						"improved"
+					]
+				},
+				additionalProps: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { format: "Boss class list is not normalized." }
+	},
+	create
+};
+
+//#endregion
+export { format_classnames_default as default };

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

@@ -0,0 +1,119 @@
+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/no-unknown-classes.js
+const RULE_NAME = "no-unknown-classes";
+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 reportInvalid = (literal) => {
+		if (!literal || !literal.value) return;
+		const invalid = require_boss_classes.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 = 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) reportInvalid(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) reportInvalid(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) reportInvalid(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) 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
+exports.default = no_unknown_classes_default;