boss-css 0.0.1 → 0.0.2

package/dist/shared/json.mjs

@@ -0,0 +1,57 @@
+//#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
+export { parseJson };

package/dist/shared/types.cjs

@@ -0,0 +1,11 @@
+
+//#region src/shared/types.ts
+let RuntimeType = /* @__PURE__ */ function(RuntimeType) {
+	RuntimeType["NODE"] = "node";
+	RuntimeType["DENO"] = "deno";
+	RuntimeType["BUN"] = "bun";
+	return RuntimeType;
+}({});
+
+//#endregion
+exports.RuntimeType = RuntimeType;

package/dist/shared/types.mjs

@@ -0,0 +1,10 @@
+//#region src/shared/types.ts
+let RuntimeType = /* @__PURE__ */ function(RuntimeType) {
+	RuntimeType["NODE"] = "node";
+	RuntimeType["DENO"] = "deno";
+	RuntimeType["BUN"] = "bun";
+	return RuntimeType;
+}({});
+
+//#endregion
+export { RuntimeType };

package/dist/strategy/classic/runtime-only.cjs

@@ -0,0 +1,190 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_names = require('../../api/names.cjs');
+const require_framework = require('../../shared/framework.cjs');
+const require_cx_index = require('../../cx/index.cjs');
+const require_use_token_runtime_only = require('../../use/token/runtime-only.cjs');
+const require_shared = require('../../prop/at/shared.cjs');
+const require_prop_at_runtime_only = require('../../prop/at/runtime-only.cjs');
+const require_prop_child_runtime_only = require('../../prop/child/runtime-only.cjs');
+const require_prop_css_runtime_only = require('../../prop/css/runtime-only.cjs');
+let _emotion_hash = require("@emotion/hash");
+_emotion_hash = require_rolldown_runtime.__toESM(_emotion_hash);
+let _boss_css_is_css_prop = require("@boss-css/is-css-prop");
+_boss_css_is_css_prop = require_rolldown_runtime.__toESM(_boss_css_is_css_prop);
+
+//#region src/strategy/classic/runtime-only.ts
+const name = "classic";
+const serializeValue = (value) => {
+	if (Array.isArray(value)) return JSON.stringify(value);
+	if (value && typeof value === "object") return JSON.stringify(value);
+	return String(value);
+};
+const resolveRuntimeValue = (value) => {
+	if (typeof value !== "function") return value;
+	return resolveRuntimeValue(value());
+};
+const buildAutoKeyframesName = (api, contexts) => {
+	return `kf-${(0, _emotion_hash.default)(`${api.selectorPrefix ?? ""}|${contexts.join("|")}`)}`;
+};
+const insertRuntimeRule = (api, className, contexts, entries) => {
+	if (!entries.length) return;
+	const css = api.css;
+	if (!css) return;
+	const selector = require_prop_css_runtime_only.buildRuntimeSelector(className, contexts);
+	const query = require_prop_at_runtime_only.resolveAtQuery(api, contexts);
+	css.selector({
+		selector,
+		query
+	});
+	for (const entry of entries) {
+		const property = require_prop_css_runtime_only.resolvePropertyName(entry.prop);
+		css.rule(property, entry.value);
+	}
+	css.write();
+};
+const collectRules = (api, input, contexts, tag, rules, keyframes) => {
+	for (const prop in input) {
+		const rawValue = input[prop];
+		if (prop === "child" && rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			for (const [selector, childValue] of Object.entries(rawValue)) {
+				const childContext = require_prop_child_runtime_only.createChildContext(selector);
+				contexts.push(childContext);
+				collectRules(api, childValue, contexts, tag, rules, keyframes);
+				contexts.pop();
+			}
+			continue;
+		}
+		if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			if (require_shared.parseKeyframesContext(prop)) {
+				const keyframesContexts = [...contexts, prop];
+				for (const [step, stepValue] of Object.entries(rawValue)) {
+					if (!stepValue || typeof stepValue !== "object" || Array.isArray(stepValue)) continue;
+					const normalizedStep = require_shared.normalizeKeyframeStep(step);
+					if (!normalizedStep) continue;
+					const stepContexts = [...keyframesContexts, step];
+					for (const [propName, valueRaw] of Object.entries(stepValue)) {
+						if (!(0, _boss_css_is_css_prop.default)(tag, propName)) continue;
+						let resolved = resolveRuntimeValue(valueRaw);
+						const token$1 = require_use_token_runtime_only.resolveRuntimeToken(api, propName, resolved);
+						if (token$1) resolved = token$1.value;
+						keyframes.push({
+							contexts: stepContexts,
+							prop: propName,
+							value: resolved,
+							keyframesContext: prop,
+							step: normalizedStep
+						});
+					}
+				}
+				continue;
+			}
+			contexts.push(prop);
+			collectRules(api, rawValue, contexts, tag, rules, keyframes);
+			contexts.pop();
+			continue;
+		}
+		if (!(0, _boss_css_is_css_prop.default)(tag, prop)) continue;
+		let value = resolveRuntimeValue(rawValue);
+		const token = require_use_token_runtime_only.resolveRuntimeToken(api, prop, value);
+		if (token) value = token.value;
+		rules.push({
+			contexts: [...contexts],
+			prop,
+			value
+		});
+	}
+};
+const onBrowserObjectStart = (api, { input, output = {}, tag, contexts = [] }) => {
+	const classNameProp = require_framework.getClassNameProp(api.framework);
+	const outputRecord = output;
+	const rules = [];
+	const keyframes = [];
+	collectRules(api, input, contexts, tag ?? "", rules, keyframes);
+	if (!rules.length && !keyframes.length) {
+		contexts.pop();
+		return;
+	}
+	const signature = [...rules, ...keyframes].map((rule) => `${rule.contexts.join("|")}|${rule.prop}|${serializeValue(rule.value)}`).sort().join(";");
+	const className = `${api.selectorPrefix ?? ""}classic-${(0, _emotion_hash.default)(signature)}`;
+	const cssClassName = require_names.escapeClassName(className);
+	outputRecord[classNameProp] = require_cx_index.cx(outputRecord[classNameProp], className);
+	const baseEntries = [];
+	const nestedEntries = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		if (!rule.contexts.length) {
+			baseEntries.push({
+				prop: rule.prop,
+				value: rule.value
+			});
+			continue;
+		}
+		const key = rule.contexts.join("|");
+		if (!nestedEntries.has(key)) nestedEntries.set(key, {
+			contexts: rule.contexts,
+			entries: []
+		});
+		nestedEntries.get(key)?.entries.push({
+			prop: rule.prop,
+			value: rule.value
+		});
+	}
+	insertRuntimeRule(api, cssClassName, [], baseEntries);
+	for (const entry of nestedEntries.values()) insertRuntimeRule(api, cssClassName, entry.contexts, entry.entries);
+	if (keyframes.length) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const entry of keyframes) {
+			let keyframesIndex = -1;
+			for (let i = entry.contexts.length - 1; i >= 0; i -= 1) if (require_shared.parseKeyframesContext(entry.contexts[i])) {
+				keyframesIndex = i;
+				break;
+			}
+			if (keyframesIndex === -1) continue;
+			const keyframesContext = entry.contexts[keyframesIndex];
+			const info = require_shared.parseKeyframesContext(keyframesContext);
+			if (!info) continue;
+			const scopeContexts = entry.contexts.slice(0, keyframesIndex + 1);
+			const groupKey = scopeContexts.join("|");
+			if (!groups.has(groupKey)) {
+				const name = info.name ?? buildAutoKeyframesName(api, scopeContexts);
+				const query = require_prop_at_runtime_only.resolveAtQuery(api, scopeContexts);
+				groups.set(groupKey, {
+					contexts: scopeContexts,
+					name,
+					query,
+					frames: /* @__PURE__ */ new Map(),
+					selectors: /* @__PURE__ */ new Set()
+				});
+			}
+			const group = groups.get(groupKey);
+			if (!group) continue;
+			const selector = require_prop_css_runtime_only.buildRuntimeSelector(cssClassName, entry.contexts);
+			group.selectors.add(selector);
+			const propertyName = require_prop_css_runtime_only.resolvePropertyName(entry.prop);
+			const valueText = api.dictionary.toValue(entry.value, propertyName);
+			if (!group.frames.has(entry.step)) group.frames.set(entry.step, /* @__PURE__ */ new Map());
+			group.frames.get(entry.step)?.set(propertyName, String(valueText));
+		}
+		const css = api.css;
+		if (!css) {
+			contexts.pop();
+			return;
+		}
+		for (const group of groups.values()) {
+			if (!group.frames.size) continue;
+			css.addRule(require_shared.buildKeyframesRule(group.name, group.frames), group.query);
+			for (const selector of group.selectors) {
+				css.selector({
+					selector,
+					query: group.query
+				});
+				css.rule("animation-name", group.name);
+				css.write();
+			}
+		}
+	}
+	contexts.pop();
+};
+
+//#endregion
+exports.name = name;
+exports.onBrowserObjectStart = onBrowserObjectStart;

package/dist/strategy/classic/runtime-only.mjs

@@ -0,0 +1,186 @@
+import { escapeClassName } from "../../api/names.mjs";
+import { getClassNameProp } from "../../shared/framework.mjs";
+import { cx } from "../../cx/index.mjs";
+import { resolveRuntimeToken } from "../../use/token/runtime-only.mjs";
+import { buildKeyframesRule, normalizeKeyframeStep, parseKeyframesContext } from "../../prop/at/shared.mjs";
+import { resolveAtQuery } from "../../prop/at/runtime-only.mjs";
+import { createChildContext } from "../../prop/child/runtime-only.mjs";
+import { buildRuntimeSelector, resolvePropertyName } from "../../prop/css/runtime-only.mjs";
+import hash from "@emotion/hash";
+import isCSSProp from "@boss-css/is-css-prop";
+
+//#region src/strategy/classic/runtime-only.ts
+const name = "classic";
+const serializeValue = (value) => {
+	if (Array.isArray(value)) return JSON.stringify(value);
+	if (value && typeof value === "object") return JSON.stringify(value);
+	return String(value);
+};
+const resolveRuntimeValue = (value) => {
+	if (typeof value !== "function") return value;
+	return resolveRuntimeValue(value());
+};
+const buildAutoKeyframesName = (api, contexts) => {
+	return `kf-${hash(`${api.selectorPrefix ?? ""}|${contexts.join("|")}`)}`;
+};
+const insertRuntimeRule = (api, className, contexts, entries) => {
+	if (!entries.length) return;
+	const css = api.css;
+	if (!css) return;
+	const selector = buildRuntimeSelector(className, contexts);
+	const query = resolveAtQuery(api, contexts);
+	css.selector({
+		selector,
+		query
+	});
+	for (const entry of entries) {
+		const property = resolvePropertyName(entry.prop);
+		css.rule(property, entry.value);
+	}
+	css.write();
+};
+const collectRules = (api, input, contexts, tag, rules, keyframes) => {
+	for (const prop in input) {
+		const rawValue = input[prop];
+		if (prop === "child" && rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			for (const [selector, childValue] of Object.entries(rawValue)) {
+				const childContext = createChildContext(selector);
+				contexts.push(childContext);
+				collectRules(api, childValue, contexts, tag, rules, keyframes);
+				contexts.pop();
+			}
+			continue;
+		}
+		if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			if (parseKeyframesContext(prop)) {
+				const keyframesContexts = [...contexts, prop];
+				for (const [step, stepValue] of Object.entries(rawValue)) {
+					if (!stepValue || typeof stepValue !== "object" || Array.isArray(stepValue)) continue;
+					const normalizedStep = normalizeKeyframeStep(step);
+					if (!normalizedStep) continue;
+					const stepContexts = [...keyframesContexts, step];
+					for (const [propName, valueRaw] of Object.entries(stepValue)) {
+						if (!isCSSProp(tag, propName)) continue;
+						let resolved = resolveRuntimeValue(valueRaw);
+						const token$1 = resolveRuntimeToken(api, propName, resolved);
+						if (token$1) resolved = token$1.value;
+						keyframes.push({
+							contexts: stepContexts,
+							prop: propName,
+							value: resolved,
+							keyframesContext: prop,
+							step: normalizedStep
+						});
+					}
+				}
+				continue;
+			}
+			contexts.push(prop);
+			collectRules(api, rawValue, contexts, tag, rules, keyframes);
+			contexts.pop();
+			continue;
+		}
+		if (!isCSSProp(tag, prop)) continue;
+		let value = resolveRuntimeValue(rawValue);
+		const token = resolveRuntimeToken(api, prop, value);
+		if (token) value = token.value;
+		rules.push({
+			contexts: [...contexts],
+			prop,
+			value
+		});
+	}
+};
+const onBrowserObjectStart = (api, { input, output = {}, tag, contexts = [] }) => {
+	const classNameProp = getClassNameProp(api.framework);
+	const outputRecord = output;
+	const rules = [];
+	const keyframes = [];
+	collectRules(api, input, contexts, tag ?? "", rules, keyframes);
+	if (!rules.length && !keyframes.length) {
+		contexts.pop();
+		return;
+	}
+	const signature = [...rules, ...keyframes].map((rule) => `${rule.contexts.join("|")}|${rule.prop}|${serializeValue(rule.value)}`).sort().join(";");
+	const className = `${api.selectorPrefix ?? ""}classic-${hash(signature)}`;
+	const cssClassName = escapeClassName(className);
+	outputRecord[classNameProp] = cx(outputRecord[classNameProp], className);
+	const baseEntries = [];
+	const nestedEntries = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		if (!rule.contexts.length) {
+			baseEntries.push({
+				prop: rule.prop,
+				value: rule.value
+			});
+			continue;
+		}
+		const key = rule.contexts.join("|");
+		if (!nestedEntries.has(key)) nestedEntries.set(key, {
+			contexts: rule.contexts,
+			entries: []
+		});
+		nestedEntries.get(key)?.entries.push({
+			prop: rule.prop,
+			value: rule.value
+		});
+	}
+	insertRuntimeRule(api, cssClassName, [], baseEntries);
+	for (const entry of nestedEntries.values()) insertRuntimeRule(api, cssClassName, entry.contexts, entry.entries);
+	if (keyframes.length) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const entry of keyframes) {
+			let keyframesIndex = -1;
+			for (let i = entry.contexts.length - 1; i >= 0; i -= 1) if (parseKeyframesContext(entry.contexts[i])) {
+				keyframesIndex = i;
+				break;
+			}
+			if (keyframesIndex === -1) continue;
+			const keyframesContext = entry.contexts[keyframesIndex];
+			const info = parseKeyframesContext(keyframesContext);
+			if (!info) continue;
+			const scopeContexts = entry.contexts.slice(0, keyframesIndex + 1);
+			const groupKey = scopeContexts.join("|");
+			if (!groups.has(groupKey)) {
+				const name = info.name ?? buildAutoKeyframesName(api, scopeContexts);
+				const query = resolveAtQuery(api, scopeContexts);
+				groups.set(groupKey, {
+					contexts: scopeContexts,
+					name,
+					query,
+					frames: /* @__PURE__ */ new Map(),
+					selectors: /* @__PURE__ */ new Set()
+				});
+			}
+			const group = groups.get(groupKey);
+			if (!group) continue;
+			const selector = buildRuntimeSelector(cssClassName, entry.contexts);
+			group.selectors.add(selector);
+			const propertyName = resolvePropertyName(entry.prop);
+			const valueText = api.dictionary.toValue(entry.value, propertyName);
+			if (!group.frames.has(entry.step)) group.frames.set(entry.step, /* @__PURE__ */ new Map());
+			group.frames.get(entry.step)?.set(propertyName, String(valueText));
+		}
+		const css = api.css;
+		if (!css) {
+			contexts.pop();
+			return;
+		}
+		for (const group of groups.values()) {
+			if (!group.frames.size) continue;
+			css.addRule(buildKeyframesRule(group.name, group.frames), group.query);
+			for (const selector of group.selectors) {
+				css.selector({
+					selector,
+					query: group.query
+				});
+				css.rule("animation-name", group.name);
+				css.write();
+			}
+		}
+	}
+	contexts.pop();
+};
+
+//#endregion
+export { name, onBrowserObjectStart };

package/dist/strategy/classname-first/runtime-only.cjs

@@ -0,0 +1,138 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_framework = require('../../shared/framework.cjs');
+const require_cx_index = require('../../cx/index.cjs');
+const require_use_token_runtime_only = require('../../use/token/runtime-only.cjs');
+const require_shared = require('../../prop/at/shared.cjs');
+const require_prop_at_runtime_only = require('../../prop/at/runtime-only.cjs');
+const require_prop_child_runtime_only = require('../../prop/child/runtime-only.cjs');
+const require_prop_css_runtime_only = require('../../prop/css/runtime-only.cjs');
+let _emotion_hash = require("@emotion/hash");
+_emotion_hash = require_rolldown_runtime.__toESM(_emotion_hash);
+let _boss_css_is_css_prop = require("@boss-css/is-css-prop");
+_boss_css_is_css_prop = require_rolldown_runtime.__toESM(_boss_css_is_css_prop);
+
+//#region src/strategy/classname-first/runtime-only.ts
+const name = "classname-first";
+const resolveRuntimeValue = (value) => {
+	if (typeof value !== "function") return value;
+	return resolveRuntimeValue(value());
+};
+const buildAutoKeyframesName = (api, contexts) => {
+	return `kf-${(0, _emotion_hash.default)(`${api.selectorPrefix ?? ""}|${contexts.join("|")}`)}`;
+};
+const handleKeyframes = (api, { output, tag, contexts, prop, value }) => {
+	const info = require_shared.parseKeyframesContext(prop);
+	if (!info || !value || typeof value !== "object" || Array.isArray(value)) return false;
+	const classNameProp = require_framework.getClassNameProp(api.framework);
+	const keyframesContexts = [...contexts, prop];
+	const keyframesName = info.name ?? buildAutoKeyframesName(api, keyframesContexts);
+	const query = require_prop_at_runtime_only.resolveAtQuery(api, keyframesContexts);
+	const frames = /* @__PURE__ */ new Map();
+	const selectors = /* @__PURE__ */ new Set();
+	for (const [step, stepValue] of Object.entries(value)) {
+		if (!stepValue || typeof stepValue !== "object" || Array.isArray(stepValue)) continue;
+		const normalizedStep = require_shared.normalizeKeyframeStep(step);
+		if (!normalizedStep) continue;
+		const stepContexts = [...keyframesContexts, step];
+		for (const [propName, rawValue] of Object.entries(stepValue)) {
+			if (!(0, _boss_css_is_css_prop.default)(tag, propName)) continue;
+			let resolved = resolveRuntimeValue(rawValue);
+			let selectorValue = resolved;
+			const token = require_use_token_runtime_only.resolveRuntimeToken(api, propName, resolved);
+			if (token) {
+				resolved = token.value;
+				selectorValue = token.selectorValue;
+			}
+			const className = api.contextToClassName(propName, selectorValue, stepContexts, false, api.selectorPrefix);
+			const cssClassName = api.contextToClassName(propName, selectorValue, stepContexts, true, api.selectorPrefix);
+			output[classNameProp] = require_cx_index.cx(output[classNameProp], className);
+			const selector = require_prop_css_runtime_only.buildRuntimeSelector(cssClassName, stepContexts);
+			selectors.add(selector);
+			const propertyName = require_prop_css_runtime_only.resolvePropertyName(propName);
+			const valueText = String(api.dictionary.toValue(resolved, propertyName));
+			if (!frames.has(normalizedStep)) frames.set(normalizedStep, /* @__PURE__ */ new Map());
+			frames.get(normalizedStep)?.set(propertyName, valueText);
+		}
+	}
+	if (!frames.size) return true;
+	const css = api.css;
+	if (!css) return true;
+	css.addRule(require_shared.buildKeyframesRule(keyframesName, frames), query);
+	for (const selector of selectors) {
+		css.selector({
+			selector,
+			query
+		});
+		css.rule("animation-name", keyframesName);
+		css.write();
+	}
+	return true;
+};
+const insertRuntimeRule = (api, className, contexts, prop, value) => {
+	const selector = require_prop_css_runtime_only.buildRuntimeSelector(className, contexts);
+	const query = require_prop_at_runtime_only.resolveAtQuery(api, contexts);
+	const property = require_prop_css_runtime_only.resolvePropertyName(prop);
+	const css = api.css;
+	if (!css) return;
+	css.selector({
+		selector,
+		query
+	});
+	css.rule(property, value);
+	css.write();
+};
+const onBrowserObjectStart = (api, { input, output = {}, tag, contexts = [] }) => {
+	const classNameProp = require_framework.getClassNameProp(api.framework);
+	const outputRecord = output;
+	const inputRecord = input;
+	for (const prop in inputRecord) {
+		const rawValue = inputRecord[prop];
+		if (prop === "child" && rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			for (const [selector, childValue] of Object.entries(rawValue)) {
+				const childContext = require_prop_child_runtime_only.createChildContext(selector);
+				contexts.push(childContext);
+				api.trigger("onBrowserObjectStart", {
+					input: childValue,
+					output,
+					contexts,
+					tag
+				});
+			}
+			continue;
+		}
+		if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+			if (handleKeyframes(api, {
+				output: outputRecord,
+				tag,
+				contexts,
+				prop,
+				value: rawValue
+			})) continue;
+			contexts.push(prop);
+			api.trigger("onBrowserObjectStart", {
+				input: rawValue,
+				output,
+				contexts,
+				tag
+			});
+			continue;
+		}
+		if (!(0, _boss_css_is_css_prop.default)(tag, prop)) continue;
+		let value = resolveRuntimeValue(rawValue);
+		let selectorValue = value;
+		const token = require_use_token_runtime_only.resolveRuntimeToken(api, prop, value);
+		if (token) {
+			value = token.value;
+			selectorValue = token.selectorValue;
+		}
+		const className = api.contextToClassName(prop, selectorValue, contexts, false, api.selectorPrefix);
+		const cssClassName = api.contextToClassName(prop, selectorValue, contexts, true, api.selectorPrefix);
+		outputRecord[classNameProp] = require_cx_index.cx(outputRecord[classNameProp], className);
+		insertRuntimeRule(api, cssClassName, contexts, prop, value);
+	}
+	contexts.pop();
+};
+
+//#endregion
+exports.name = name;
+exports.onBrowserObjectStart = onBrowserObjectStart;