@animus-ui/system 0.1.20 → 0.1.22

package/dist/createComposedFamily-BbA_d0QH.js

@@ -0,0 +1,195 @@
+import { n as resolveClasses } from "./createClassResolver-DtHjTYa7.js";
+import { t as assertRootSlot } from "./assert-root-slot-C3Lp9MNJ.js";
+import { Children, cloneElement, createElement, forwardRef } from "react";
+//#region src/runtime/index.ts
+/** Sets one ref, returning the cleanup a callback ref hands back, if any. */
+function setRef(ref, value) {
+	if (typeof ref === "function") {
+		const cleanup = ref(value);
+		return typeof cleanup === "function" ? cleanup : void 0;
+	}
+	if (ref) ref.current = value;
+}
+/**
+* Attaches every ref. When one hands back a cleanup (React 19), the merged
+* callback returns a cleanup that runs it and resets the others with null.
+* Otherwise it returns nothing, since React 18 warns on a returned function,
+* and React detaches by calling it with null, which reaches every ref.
+*/
+function mergeRefs(parent, child) {
+	return (node) => {
+		const refs = [parent, child];
+		const cleanups = refs.map((ref) => setRef(ref, node));
+		if (!cleanups.some(Boolean)) return;
+		return () => {
+			refs.forEach((ref, index) => {
+				const cleanup = cleanups[index];
+				if (cleanup) cleanup();
+				else setRef(ref, null);
+			});
+		};
+	};
+}
+const mergedRefs = /* @__PURE__ */ new WeakMap();
+/**
+* The ref an asChild element gets. A single ref needs no merging; a pair gets
+* one merged callback, cached by the refs themselves, so a re-render with
+* unchanged refs hands React the same callback and the refs stay attached.
+* The runtime is hook-free so components work in server components, which
+* rules per-instance memoization out.
+*/
+function composeRefs(parent, child) {
+	if (!parent) return child;
+	if (!child) return parent;
+	let byChild = mergedRefs.get(parent);
+	if (!byChild) {
+		byChild = /* @__PURE__ */ new WeakMap();
+		mergedRefs.set(parent, byChild);
+	}
+	let merged = byChild.get(child);
+	if (!merged) {
+		merged = mergeRefs(parent, child);
+		byChild.set(child, merged);
+	}
+	return merged;
+}
+/**
+* `data-*` and `aria-*` reach the DOM even when they key a variant or state,
+* so headless libraries driving those attributes still see them.
+*/
+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;
+	}
+}
+/**
+* React 19 carries a ref as a plain prop and warns on `element.ref`; React 18
+* keeps it on the element and guards `props.ref` with a warning getter.
+* Reading the descriptor never invokes either getter.
+*/
+function childRefOf(child) {
+	const propRef = Object.getOwnPropertyDescriptor(child.props, "ref");
+	if (propRef && !propRef.get) return propRef.value;
+	return child.ref;
+}
+/**
+* The child wins every conflict: the slot's props spread under the child's
+* own, so a handler declared on the child replaces the slot's instead of
+* chaining. `variables`, Animus's own dynamic styles, win over the child's.
+*/
+function renderSlot(children, props, ref, variables) {
+	const child = Children.only(children);
+	const { asChild: _asChild, children: _children, className, ref: propRef, style, ...slotProps } = props;
+	const mergedClassName = [className, child.props.className].filter(Boolean).join(" ");
+	const mergedStyle = variables || style || child.props.style ? {
+		...style,
+		...child.props.style,
+		...variables
+	} : void 0;
+	return cloneElement(child, {
+		...slotProps,
+		...child.props,
+		ref: composeRefs(ref ?? propRef, childRefOf(child)),
+		className: mergedClassName,
+		...mergedStyle ? { style: mergedStyle } : {}
+	});
+}
+/**
+* Renders an `asChild` slot exactly as Animus renders its own: the one child
+* element, with `props` spread under the child's props so the child wins
+* every conflict, class names joined (the slot's first), styles merged and
+* both refs attached. An `asComponent` target that receives `asChild` calls
+* it in place of its element:
+*
+* ```tsx
+* if (asChild) return renderAsChild(children, props, ref);
+* ```
+*
+* `asChild` and `children` in `props` are dropped, and `ref` defaults to
+* `props.ref`. It throws unless `children` is exactly one React element.
+*
+* An `asComponent` component types `children` as any `ReactNode`, whatever
+* the target declares, so a target rendering a void element such as `input`
+* leaves its children out without `asChild`, where React would throw.
+*/
+function renderAsChild(children, props, ref) {
+	return renderSlot(children, props, ref);
+}
+/**
+* A string terminal renders `as` in place of its tag. A component terminal
+* always renders its component, which receives `as` and `asChild` like any
+* other prop, so its own wiring runs whatever element it ends up rendering.
+*/
+function renderElement(element, filterProps, props, ref, classes, dynamicStyle) {
+	const target = typeof element === "string" ? props.as || element : 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);
+}
+function createComponent(element, className, config, systemPropMap, dynamicPropConfig) {
+	const variantProps = config.variants ? Object.keys(config.variants) : [];
+	const stateProps = config.states || [];
+	const systemPropNames = config.systemPropNames || [];
+	const ownsPolymorphism = typeof element === "string";
+	const filterProps = /* @__PURE__ */ new Set([
+		...ownsPolymorphism ? ["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);
+		if (props.asChild && ownsPolymorphism) {
+			const slotProps = { className: classes.join(" ") };
+			forwardProps(props, filterProps, slotProps);
+			return renderSlot(props.children, slotProps, ref, dynamicStyle);
+		}
+		return 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;
+	}
+	const customTransforms = {};
+	for (const [prop, dc] of Object.entries(config.customDynamicConfig ?? {})) if (dc.transform) customTransforms[prop] = dc.transform;
+	return Object.assign(Component, {
+		variantDefaults: Object.freeze(variantDefaults),
+		customTransforms: Object.freeze(customTransforms),
+		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/createComposedFamily.ts
+/**
+* The extraction emitter rewrites `compose()` calls to this form. It stays
+* hook- and context-free so composed families work in server components.
+*/
+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 { createComponent as n, renderAsChild as r, createComposedFamily as t };

package/dist/createComposedFamily-BkrvSsfl.d.ts

@@ -0,0 +1,40 @@
+import { a as DynamicPropConfig, i as ClassResolverConfig, o as SystemPropMap } from "./createClassResolver-Do1nmvkf.js";
+import { ForwardRefExoticComponent, ReactElement, ReactNode, Ref, forwardRef } from "react";
+//#region src/runtime/index.d.ts
+interface ComponentConfig extends ClassResolverConfig {}
+type ElementType = string | React.ComponentType<any>;
+type Transform = NonNullable<DynamicPropConfig[string]['transform']>;
+type AnimusComponent = ReturnType<typeof forwardRef> & {
+  extend: () => never;
+  variantDefaults: Readonly<Record<string, string>>;
+  customTransforms: Readonly<Record<string, Transform>>;
+};
+/**
+ * Renders an `asChild` slot exactly as Animus renders its own: the one child
+ * element, with `props` spread under the child's props so the child wins
+ * every conflict, class names joined (the slot's first), styles merged and
+ * both refs attached. An `asComponent` target that receives `asChild` calls
+ * it in place of its element:
+ *
+ * ```tsx
+ * if (asChild) return renderAsChild(children, props, ref);
+ * ```
+ *
+ * `asChild` and `children` in `props` are dropped, and `ref` defaults to
+ * `props.ref`. It throws unless `children` is exactly one React element.
+ *
+ * An `asComponent` component types `children` as any `ReactNode`, whatever
+ * the target declares, so a target rendering a void element such as `input`
+ * leaves its children out without `asChild`, where React would throw.
+ */
+declare function renderAsChild(children: ReactNode, props: object, ref?: Ref<any>): ReactElement;
+declare function createComponent(element: ElementType, className: string, config: ComponentConfig, systemPropMap?: SystemPropMap, dynamicPropConfig?: DynamicPropConfig): AnimusComponent;
+//#endregion
+//#region src/runtime/createComposedFamily.d.ts
+interface ComposedFamilyConfig {
+  name: string;
+}
+declare function createComposedFamily(slots: Record<string, ForwardRefExoticComponent<any>>, config: ComposedFamilyConfig): Record<string, ForwardRefExoticComponent<any>>;
+//#endregion
+export { createComponent as n, renderAsChild as r, createComposedFamily as t };
+//# sourceMappingURL=createComposedFamily-BkrvSsfl.d.ts.map

package/dist/createComposedFamily-BkrvSsfl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createComposedFamily-BkrvSsfl.d.ts","names":[],"sources":["../src/runtime/index.ts","../src/runtime/createComposedFamily.ts"],"mappings":";;;UAgBU,wBAAwB;KAE7B,uBAAuB,MAAM;KAE7B,YAAY,YAAY;KAExB,kBAAkB,kBAAkB;EACvC;EACA,iBAAiB,SAAS;EAC1B,kBAAkB,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;iBAyJ5B,cACd,UAAU,WACV,eACA,MAAM,WACL;iBAkCa,gBACd,SAAS,aACT,mBACA,QAAQ,iBACR,gBAAgB,eAChB,oBAAoB,oBACnB;;;UChNO;EACR;;iBAGc,qBACd,OAAO,eAAe,iCACtB,QAAQ,uBACP,eAAe"}