@animus-ui/system 0.1.16 → 0.1.18

package/dist/createClassResolver-EpwTL9Sa.js

@@ -1,228 +0,0 @@
-import { isUnitlessProperty } from "@animus-ui/properties";
-//#region src/runtime/is-dev.ts
-/**
-* The define token is tested as the initializer's own conditional, never from
-* inside the fallback: only there can a minifier drop the dev-gated code.
-*/
-const IS_DEV = typeof __ANIMUS_DEV__ === "boolean" ? __ANIMUS_DEV__ : (() => {
-	try {
-		if (typeof process !== "undefined" && typeof process.env === "undefined") return true;
-		return process.env.NODE_ENV !== "production";
-	} catch {
-		return false;
-	}
-})();
-//#endregion
-//#region src/runtime/witness.ts
-const WITNESS_CAP = 5e3;
-function recordWitness(component, prop, value, outcome) {
-	if (!IS_DEV) return;
-	const g = globalThis;
-	const buf = g.__ANIMUS_WITNESS__ ??= [];
-	buf.push({
-		component,
-		prop,
-		value: String(value),
-		outcome
-	});
-	if (buf.length > 5e3) buf.splice(0, buf.length - WITNESS_CAP);
-}
-//#endregion
-//#region src/runtime/resolveClasses.ts
-/**
-* A mixed property set resolves to unitless: a bare number on a length
-* property is dropped by the parser, `px` on a unitless one shifts layout.
-*/
-function applyUnitFallback(value, cssProperties) {
-	if (typeof value === "number") {
-		if (cssProperties.some(isUnitlessProperty)) return String(value);
-		return `${value}px`;
-	}
-	return String(value);
-}
-/**
-* The key format is fixed by the Rust css generator; a divergence here misses
-* every static class lookup.
-*/
-function serializeValueKey(value) {
-	if (typeof value === "number" || typeof value === "string") return String(value);
-	if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.keys(value).sort().map((k) => `${k}:${value[k]}`).join("|");
-	return String(value);
-}
-function isValidTransformResult(result) {
-	return typeof result === "string" || typeof result === "number" && Number.isFinite(result);
-}
-/**
-* The domain is results that failed `isValidTransformResult`; a valid string
-* or finite number passed here is mislabeled.
-*/
-function describeResultShape(result) {
-	if (result === null) return "null";
-	if (Array.isArray(result)) return "array";
-	if (typeof result === "number") return "non-finite-number";
-	return typeof result;
-}
-function resolveEntry(value, dc) {
-	const key = String(value);
-	const scaleResolved = dc.scaleValues?.[key];
-	if (scaleResolved != null) {
-		const transformed = dc.transform ? dc.transform(scaleResolved) : scaleResolved;
-		if (dc.transform && !isValidTransformResult(transformed)) return { shape: describeResultShape(transformed) };
-		return String(transformed);
-	}
-	const transformed = dc.transform ? dc.transform(value) : value;
-	if (dc.transform && !isValidTransformResult(transformed)) return { shape: describeResultShape(transformed) };
-	if (typeof transformed !== "number") return String(transformed);
-	return applyUnitFallback(transformed, dc.properties && dc.properties.length > 0 ? dc.properties : dc.property ? [dc.property] : []);
-}
-const warnedDrops = /* @__PURE__ */ new Set();
-function warnDroppedValue(baseClassName, propName, serializedValue) {
-	if (IS_DEV) {
-		const dedupeKey = `${baseClassName}|${propName}`;
-		if (warnedDrops.has(dedupeKey)) return;
-		warnedDrops.add(dedupeKey);
-		console.warn(`[animus:drop] ${baseClassName}: value ${serializedValue} on prop '${propName}' matched no static class and no dynamic slot — it will not render. If this prop should accept runtime values, ensure its dynamic config is emitted.`);
-	}
-}
-/**
-* A value taken from a variant default emits `--{prop}-default`, not the
-* value, so the compose override rule misses and the parent's value wins.
-*/
-function applyVariantClasses(classes, baseClassName, props, config) {
-	if (!config.variants) return;
-	for (const [prop, vc] of Object.entries(config.variants)) {
-		const value = props[prop] ?? vc.default;
-		if (value != null) {
-			const isDefault = !(prop in props) && vc.default != null;
-			classes.push(`${baseClassName}--${prop}-${isDefault ? "default" : value}`);
-			recordWitness(baseClassName, prop, value, "static");
-		}
-	}
-}
-function applyCompoundClasses(classes, props, config) {
-	if (!config.compounds) return;
-	for (const compound of config.compounds) {
-		let match = true;
-		for (const [prop, expected] of Object.entries(compound.conditions)) {
-			const current = props[prop] ?? config.variants?.[prop]?.default;
-			if (Array.isArray(expected) ? !expected.includes(current) : current !== expected) {
-				match = false;
-				break;
-			}
-		}
-		if (match) classes.push(compound.className);
-	}
-}
-function applyStateClasses(classes, baseClassName, props, config, activeStates) {
-	if (!config.states) return;
-	for (const state of config.states) if (props[state]) {
-		classes.push(`${baseClassName}--${state}`);
-		activeStates.push(state);
-		recordWitness(baseClassName, state, "true", "static");
-	}
-}
-const warnedInvalidResults = /* @__PURE__ */ new Set();
-function warnInvalidTransformResult(baseClassName, propName, shape) {
-	if (IS_DEV) {
-		const dedupeKey = `${baseClassName}|${propName}`;
-		if (warnedInvalidResults.has(dedupeKey)) return;
-		warnedInvalidResults.add(dedupeKey);
-		console.warn(`[animus:drop] ${baseClassName}: transform for prop '${propName}' returned ${shape} — expected string or finite number; value dropped`);
-	}
-}
-/**
-* Resolution is staged so a drop is atomic: one invalid transform result
-* anywhere leaves `classes` and `dynStyle` untouched.
-*/
-function applyDynamicProp(classes, dynStyle, propValue, dc) {
-	const staged = [];
-	if (typeof propValue === "object" && propValue !== null && !Array.isArray(propValue)) for (const [bp, bpVal] of Object.entries(propValue)) {
-		if (bpVal == null) continue;
-		const resolved = resolveEntry(bpVal, dc);
-		if (typeof resolved !== "string") return resolved;
-		staged.push(bp === "_" ? [
-			dc.slotClass,
-			dc.varName,
-			resolved
-		] : [
-			`${dc.slotClass}-${bp}`,
-			`${dc.varName}-${bp}`,
-			resolved
-		]);
-	}
-	else {
-		const resolved = resolveEntry(propValue, dc);
-		if (typeof resolved !== "string") return resolved;
-		staged.push([
-			dc.slotClass,
-			dc.varName,
-			resolved
-		]);
-	}
-	for (const [slotClass, varName, resolved] of staged) {
-		classes.push(slotClass);
-		dynStyle[varName] = resolved;
-	}
-	return null;
-}
-function resolveClasses(baseClassName, props, config, systemPropMap, dynamicPropConfig) {
-	const classes = [baseClassName];
-	let dynStyle;
-	applyVariantClasses(classes, baseClassName, props, config);
-	applyCompoundClasses(classes, props, config);
-	const activeStates = [];
-	applyStateClasses(classes, baseClassName, props, config, activeStates);
-	const systemPropNames = config.systemPropNames || [];
-	if (systemPropNames.length > 0) {
-		const { customPropMap, customDynamicConfig } = config;
-		for (const propName of systemPropNames) {
-			if (!(propName in props)) continue;
-			const propValue = props[propName];
-			if (propValue == null) continue;
-			const key = serializeValueKey(propValue);
-			const cls = customPropMap?.[propName]?.[key] ?? systemPropMap?.[propName]?.[key];
-			if (cls) {
-				classes.push(cls);
-				recordWitness(baseClassName, propName, key, "static");
-			} else {
-				const dc = customDynamicConfig?.[propName] ?? dynamicPropConfig?.[propName];
-				if (dc) {
-					const staged = dynStyle ?? {};
-					const invalid = applyDynamicProp(classes, staged, propValue, dc);
-					if (invalid === null) {
-						dynStyle = staged;
-						recordWitness(baseClassName, propName, key, "dynamic");
-					} else {
-						warnInvalidTransformResult(baseClassName, propName, invalid.shape);
-						recordWitness(baseClassName, propName, key, "drop");
-					}
-				} else {
-					warnDroppedValue(baseClassName, propName, key);
-					recordWitness(baseClassName, propName, key, "drop");
-				}
-			}
-		}
-	}
-	return {
-		classes,
-		dynamicStyle: dynStyle,
-		activeStates
-	};
-}
-//#endregion
-//#region src/runtime/createClassResolver.ts
-function serializeDynamicStyle(style) {
-	return Object.entries(style).map(([property, value]) => `${property}: ${value}`).join("; ");
-}
-function createClassResolver(className, config, systemPropMap, dynamicPropConfig) {
-	const resolveAttributes = (props) => {
-		const { classes, dynamicStyle } = resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig);
-		const attributes = { class: classes.join(" ") };
-		if (dynamicStyle && Object.keys(dynamicStyle).length > 0) attributes.style = serializeDynamicStyle(dynamicStyle);
-		return attributes;
-	};
-	const resolver = (props) => resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig).classes.join(" ");
-	return Object.assign(resolver, { attrs: resolveAttributes });
-}
-//#endregion
-export { resolveClasses as n, createClassResolver as t };