@animus-ui/system 0.1.9 → 0.1.12

package/dist/createComposedFamily-3ZugjBpU.js

@@ -1,472 +0,0 @@
-import { t as assertRootSlot } from "./assert-root-slot-B83scqPh.js";
-import { Children, cloneElement, createElement, forwardRef, isValidElement } from "react";
-import { isUnitlessProperty } from "@animus-ui/properties";
-//#region src/runtime/is-dev.ts
-/**
-* The runtime's dev-build signal, shared by every development-only path
-* (drop diagnostic, reachability witness). Several hosts have to be satisfied
-* at once, and they force this exact shape:
-*
-* - **Bundles built through an Animus plugin.** `__ANIMUS_DEV__` is a
-*   build-time define supplied by the Vite plugin's `config` hook and by the
-*   Next plugin's DefinePlugin entry, each keyed on its bundler's own
-*   dev/build signal. It is tested FIRST, and as the CONDITIONAL OF THE
-*   INITIALIZER ITSELF — not as an early return inside the IIFE below. That
-*   distinction is the whole point: define-replacement turns the test into
-*   `typeof false === 'boolean'`, and only in this position does the
-*   production minifier propagate the resulting constant into every `IS_DEV`
-*   reference, so the gated branches and their diagnostic strings leave the
-*   bundle entirely. Hidden inside the IIFE, the same guard collapses to a
-*   variable the minifier keeps, and every diagnostic string ships. Never
-*   "tidy" this ternary into the fallback.
-* - **Browser bundles without the define.** `process.env.NODE_ENV` is a define
-*   token that Vite and Next rewrite to a string literal; `typeof process` is
-*   not rewritten by anything, so guarding the token with it strands every dev
-*   branch in a browser (no `process` global → the conjunction is false in dev
-*   too). The token must therefore be read bare.
-* - **Next under Turbopack.** The Next plugin supplies the define from its
-*   `webpack()` hook, and a Turbopack-active run never calls that hook (the
-*   Turbopack path wires rules and aliases instead), so those builds carry no
-*   token and land on the `process.env.NODE_ENV` fallback below — correct
-*   answer, no elimination.
-* - **QuickJS (the Rust system-loader).** It evaluates the system dist with no
-*   define pass and no `process`, so the `typeof` test is simply false and the
-*   bare read then throws ReferenceError at module scope — caught here, and
-*   not-dev is the correct answer for a loader that only reads config.
-*   `import.meta` is unavailable there (a script-context eval makes it a syntax
-*   error), so it is never used.
-* - **Node (SSR, tests).** Reads the real `process.env.NODE_ENV`.
-*
-* Evaluated once, at module load: in every host the answer is fixed for the
-* lifetime of the bundle.
-*
-* The define is the sanctioned foldable path, and the only one. The try/catch
-* fallback is deliberately NOT foldable — a host that supplies no token keeps
-* its (gated-off, never-executed) diagnostic strings, which is the accepted
-* price of a diagnostic that actually fires in a browser dev build. Restore
-* elimination by supplying the define from a bundler plugin.
-*/
-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
-/**
-* Dev-mode reachability witness: records every class-resolution outcome into a
-* bounded in-page ring buffer at globalThis.__ANIMUS_WITNESS__. Development
-* only — a production build records nothing and never creates the handle
-* (IS_DEV is false). See is-dev.ts for the define/fold story and which hosts
-* eliminate this code rather than merely gate it off. The handle name is the
-* greppable exclusion token.
-*/
-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
-/**
-* Apply unit fallback to a value for the CSS properties the value lands on.
-* `isUnitlessProperty` owns the spelling question, so either convention works.
-*
-* A mixed property set resolves to unitless: an unsuffixed number on a length
-* property is dropped by the CSS parser, whereas `px` on a unitless property
-* renders and silently changes layout — prefer the drop.
-*
-* An empty property list keeps the unconditional `px` — configs emitted before
-* `property` was carried name no property at all.
-*/
-function applyUnitFallback(value, cssProperties) {
-	if (typeof value === "number") {
-		if (cssProperties.some(isUnitlessProperty)) return String(value);
-		return `${value}px`;
-	}
-	return String(value);
-}
-/**
-* Serialize a system prop value to a lookup key matching the Rust
-* css_generator's serialize_value_key output format.
-*/
-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);
-}
-/**
-* Validity predicate for transform results (design D5): only strings and
-* finite numbers may reach the stylesheet. The gate applies solely where a
-* configured transform ran — scale hits without a transform are exempt.
-*/
-function isValidTransformResult(result) {
-	return typeof result === "string" || typeof result === "number" && Number.isFinite(result);
-}
-/**
-* Shape descriptor for an invalid transform result, shared by the drop
-* warning and its tests. `null` and arrays are named before `typeof` would
-* fold them into `object`; non-finite numbers get their own name because
-* finite ones are valid. Precondition: callers pass only results that failed
-* `isValidTransformResult` — valid strings/finite numbers are out of domain
-* and would be 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;
-}
-/**
-* Resolve one entry through scale lookup → transform → unit fallback,
-* validating the transform result in both the scale-resolved and raw arms.
-* An invalid result yields its shape descriptor instead of a string.
-*/
-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.`);
-	}
-}
-/**
-* Apply variant classes in declaration order, recording a static witness per
-* resolved variant. When a value comes from a defaultVariant fallback (prop not
-* passed), emit --{prop}-default instead of --{prop}-{value} so the compose
-* override rule cannot match, allowing inheritance from the parent to win.
-*/
-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");
-		}
-	}
-}
-/**
-* Apply compound classes: push each compound's className when every condition
-* matches (against the prop value or its variant default). No witness records.
-*/
-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);
-	}
-}
-/**
-* Apply state classes and track active states for data-attribute passthrough,
-* recording a static witness per active state.
-*/
-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`);
-	}
-}
-/**
-* Expand a resolved dynamic prop into slot classes and CSS-variable style
-* entries. Responsive objects expand per breakpoint: the `_` base breakpoint
-* uses the bare slotClass and varName; named breakpoints suffix both
-* (`${slotClass}-${bp}` and `${varName}-${bp}`). Scalar values push the bare
-* slotClass and set varName directly.
-*
-* Two-phase so the drop is atomic: every entry resolves into a staging list
-* before any mutation. One invalid transform result anywhere — the scalar, or
-* any single breakpoint — returns that failure (first offending shape) with
-* `classes` and `dynStyle` untouched. On success the staged entries apply in
-* the pre-existing push order and the function returns `null`; the caller
-* records the witness from the outcome.
-*/
-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;
-}
-/**
-* Resolve className parts from props, using extracted configuration.
-* This is the shared logic between createComponent and createClassResolver.
-*/
-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/index.ts
-/**
-* Merge multiple refs (callback or object) into a single callback ref.
-* Creates a new callback on each call — no memoization possible in a
-* hook-free runtime (RSC compatibility). Matches @radix-ui/react-compose-refs.
-*/
-function composeRefs(...refs) {
-	return (node) => {
-		for (const ref of refs) if (typeof ref === "function") ref(node);
-		else if (ref) ref.current = node;
-	};
-}
-/**
-* Forward props to the underlying element, filtering out Animus-managed props.
-*
-* data-* and aria-* attributes always pass through to the DOM, even when used
-* as variant/state keys. This enables headless UI interop: the attribute is
-* consumed for styling AND forwarded to the element so external frameworks
-* (Radix, Ark-UI) see it.
-*
-* filterProps covers all Animus props, so unknown props pass through: for DOM
-* elements React handles any unknown-attribute warnings in dev mode, and for
-* component elements all non-filtered props are forwarded to the component.
-*/
-function forwardProps(props, filterProps, domProps) {
-	for (const [key, value] of Object.entries(props)) {
-		if (key === "className") continue;
-		if (!(key.startsWith("data-") || key.startsWith("aria-")) && filterProps.has(key)) continue;
-		domProps[key] = value;
-	}
-}
-/**
-* asChild render path: don't render our own element — merge the resolved
-* className/ref/style onto the single child element, plus the parent's own
-* forwardable props (event handlers, role, aria-*, data-*, id, tabIndex).
-*
-* Conflict rule is child-wins: the parent's props are spread UNDER the child's
-* own, so a handler or attribute declared on the child replaces the parent's
-* rather than chaining with it.
-*/
-function renderAsChild(className, filterProps, props, ref, classes, dynamicStyle) {
-	const child = Children.only(props.children);
-	if (!isValidElement(child)) throw new Error(`${className}: asChild requires a single React element as children`);
-	const childRef = child.ref;
-	const mergedClassName = [classes.join(" "), child.props.className].filter(Boolean).join(" ");
-	const mergedStyle = dynamicStyle || props.style || child.props.style ? {
-		...props.style,
-		...child.props.style,
-		...dynamicStyle
-	} : void 0;
-	const parentProps = {};
-	forwardProps(props, filterProps, parentProps);
-	delete parentProps.children;
-	delete parentProps.style;
-	delete parentProps.ref;
-	return cloneElement(child, {
-		...parentProps,
-		...child.props,
-		ref: composeRefs(ref, childRef),
-		className: mergedClassName,
-		...mergedStyle ? { style: mergedStyle } : {}
-	});
-}
-/**
-* Normal render path: render our own element (or the `as` override), forwarding
-* filtered props and applying any dynamic CSS-variable style.
-*/
-function renderElement(element, filterProps, props, ref, classes, dynamicStyle) {
-	const target = props.as || element;
-	const domProps = {
-		ref,
-		className: classes.join(" ")
-	};
-	forwardProps(props, filterProps, domProps);
-	if (dynamicStyle) domProps.style = props.style ? {
-		...props.style,
-		...dynamicStyle
-	} : dynamicStyle;
-	return createElement(target, domProps);
-}
-/**
-* Create a lightweight component that applies extracted CSS class names.
-* Replaces Emotion's styled() for extracted components.
-*
-* The element parameter accepts either an HTML tag string (e.g. 'button') or
-* a React component reference (e.g. NextLink). When a component reference is
-* used, prop forwarding skips the HTML-attribute validity check — all
-* non-filtered props are forwarded to the component.
-*
-* The optional systemPropMap parameter provides the shared prop→value→className
-* lookup table, served as a virtual module by the Vite plugin.
-*
-* The optional dynamicPropConfig parameter provides CSS variable fallback
-* metadata for props with detected dynamic usage.
-*/
-function createComponent(element, className, config, systemPropMap, dynamicPropConfig) {
-	const variantProps = config.variants ? Object.keys(config.variants) : [];
-	const stateProps = config.states || [];
-	const systemPropNames = config.systemPropNames || [];
-	const filterProps = new Set([
-		"as",
-		"asChild",
-		...variantProps,
-		...stateProps,
-		...systemPropNames
-	]);
-	const Component = forwardRef((props, ref) => {
-		const { classes, dynamicStyle } = resolveClasses(className, props, config, systemPropMap, dynamicPropConfig);
-		if (props.className) classes.push(props.className);
-		return props.asChild ? renderAsChild(className, filterProps, props, ref, classes, dynamicStyle) : renderElement(element, filterProps, props, ref, classes, dynamicStyle);
-	});
-	Component.displayName = className;
-	const variantDefaults = {};
-	if (config.variants) {
-		for (const [prop, vc] of Object.entries(config.variants)) if (vc.default != null) variantDefaults[prop] = vc.default;
-	}
-	return Object.assign(Component, {
-		variantDefaults: Object.freeze(variantDefaults),
-		extend: () => {
-			throw new Error(`Cannot extend extracted component "${className}" at runtime. Extensions must be authored in source code using the builder API (e.g. import the original component and call .extend() there) so the extraction pipeline can resolve them at build time.`);
-		}
-	});
-}
-//#endregion
-//#region src/runtime/createClassResolver.ts
-/**
-* createClassResolver — framework-agnostic className resolution.
-*
-* Produced by .asClass() terminal. Same resolution logic as createComponent
-* (variants, states, compounds, system props) but returns a className string
-* instead of a React element.
-*/
-function createClassResolver(className, config, systemPropMap, dynamicPropConfig) {
-	return (props) => {
-		const { classes } = resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig);
-		return classes.join(" ");
-	};
-}
-//#endregion
-//#region src/runtime/createComposedFamily.ts
-/**
-* createComposedFamily — extraction-time replacement for compose().
-*
-* The transform emitter replaces `compose({ Root, Body }, { shared, name })`
-* with `createComposedFamily({ Root, Body }, { name })`.
-*
-* RSC-safe: uses only forwardRef and createElement — no createContext,
-* no useContext, no hooks.
-*/
-function createComposedFamily(slots, config) {
-	assertRootSlot(slots, "createComposedFamily");
-	const { name } = config;
-	const result = {};
-	for (const [slotName, SourceComponent] of Object.entries(slots)) {
-		const Wrapper = forwardRef((props, ref) => createElement(SourceComponent, {
-			...props,
-			ref
-		}, props.children));
-		Wrapper.displayName = `${name}.${slotName}`;
-		result[slotName] = Wrapper;
-	}
-	return result;
-}
-//#endregion
-export { createClassResolver as n, createComponent as r, createComposedFamily as t };