@yahoo/uds-v5-wip 1.34.0 → 1.36.0

package/dist/config/dist/resolveStyleProp.js

@@ -1,2 +1,188 @@
-import "./resolveTokenTypes.js";
-import "./propertyAcceptedTypes.js";
+import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
+import "../../utils/dist/index.js";
+import { isTokenAcceptedByProperty } from "./propertyAcceptedTypes.js";
+import { sniffTokenTypeFromValue } from "./resolveTokenTypes.js";
+//#region ../config/dist/resolveStyleProp.js
+/**
+* Resolve a {@link StyleProp} authored via `defineStyleProp` against the
+* active UDS config, producing a flat list of accepted tokens, literal
+* keywords, and the arbitrary spec — the data that downstream codegen
+* consumes to populate `Custom*` interfaces and emit utility CSS.
+*
+* Filtering invariant: a token is exposed in the resolved pool only when
+* its detected CSS value type is accepted by the prop's `cssProperty`,
+* per {@link PROPERTY_ACCEPTED_TYPES}. Properties absent from that table
+* accept every token.
+*
+* The resolver is pure — given the same `(StyleProp, UdsConfigData)` input
+* it returns the same output. Group lookups are by `namespace` (with a
+* fallback to `cssPrefix`) on the resolved config's `atomic` array.
+*/
+/**
+* Map the legacy 8-entry `TokenType` enum to a {@link CssValueTypeName}.
+* The `'dimension'` case is ambiguous (length vs. percentage); callers
+* disambiguate by sniffing the value string.
+*/
+function tokenTypeToValueType(t) {
+	switch (t) {
+		case "color": return "color";
+		case "dimension": return "length-percentage";
+		case "number": return "number";
+		case "fontFamily": return "font-family";
+		case "fontWeight": return "font-weight";
+		case "duration": return "time";
+		case "strokeStyle": return "string";
+		case "string": return "string";
+		default: return;
+	}
+}
+/**
+* A value looks like a CSS shadow when it combines at least one length
+* (offset/blur/spread) with a color reference. Catches both single-shadow
+* (`'0 1px 2px rgba(...)'`) and multi-shadow (`'..., ...'`) forms, plus
+* inset shadows. Used to refine `'string'`-typed tokens to the more precise
+* `'shadow'` value type so they pass the runtime filter on `box-shadow` /
+* `text-shadow` props.
+*/
+const SHADOW_LENGTH_RE = /(?:^|[\s,])-?\d+(?:\.\d+)?(?:px|rem|em|ch|ex)/i;
+const SHADOW_COLOR_RE = /(?:rgba?|hsla?|color|oklch|oklab|lch|lab|hwb)\(|#[0-9a-fA-F]{3,8}\b/;
+function looksLikeShadow(value) {
+	const trimmed = value.trim();
+	return SHADOW_LENGTH_RE.test(trimmed) && SHADOW_COLOR_RE.test(trimmed);
+}
+/**
+* Detect a token's CSS value type. Resolution order:
+*  1. Per-token `type` override.
+*  2. Group-level `type`.
+*  3. Value sniff via {@link sniffTokenTypeFromValue}.
+*
+* When the resolved type is `'length-percentage'` and the raw value ends in
+* `%`, narrow to `'percentage'`; otherwise narrow to `'length'`. When the
+* resolved type is `'string'` but the value looks like a shadow expression,
+* narrow to `'shadow'`.
+*/
+function detectTokenValueType(token, group) {
+	const explicit = token.type ?? group.type;
+	let resolved;
+	if (explicit) resolved = tokenTypeToValueType(explicit);
+	else {
+		const sniffed = sniffTokenTypeFromValue(token.value);
+		resolved = sniffed ? tokenTypeToValueType(sniffed) : void 0;
+	}
+	if (resolved === "length-percentage") return token.value.trim().endsWith("%") ? "percentage" : "length";
+	if (resolved === "string" && looksLikeShadow(token.value)) return "shadow";
+	return resolved;
+}
+const REF_RE = /^\{([^.{}]+)(?:\.([^.{}]+))?\}$/;
+/**
+* Parse a string ref like `'{palette}'` or `'{spacing.4}'`. Returns
+* `undefined` for any string that isn't a brace ref (so the caller can
+* treat it as a literal keyword).
+*/
+function parseGroupRef(raw) {
+	const m = REF_RE.exec(raw);
+	if (!m) return void 0;
+	const [, group, key] = m;
+	if (!group) return void 0;
+	return key !== void 0 ? {
+		group,
+		key
+	} : { group };
+}
+function findGroup(atomic, name) {
+	return atomic.find((g) => g.namespace === name || g.cssPrefix === name);
+}
+function isNamespacedRef(entry) {
+	return typeof entry === "object" && entry !== null && "ref" in entry && "namespace" in entry;
+}
+/**
+* Build `--{configPrefix}-{varPrefix}-{safeName}` (or omit the configPrefix
+* when empty). Mirrors `buildTokenVarName` in `@uds/codegen/css/prepareCss`.
+*/
+function buildCssVar(configPrefix, varPrefix, safeName) {
+	return configPrefix ? `--${configPrefix}-${varPrefix}-${safeName}` : `--${varPrefix}-${safeName}`;
+}
+function resolveGroupTokens(group, cssProperty, configPrefix, namespace) {
+	const groupName = group.namespace ?? group.cssPrefix ?? "";
+	const varPrefix = group.cssPrefix ?? group.namespace ?? "";
+	const out = [];
+	for (const token of group.tokens) {
+		const valueType = detectTokenValueType(token, group);
+		if (!isTokenAcceptedByProperty(cssProperty, valueType, token.value)) continue;
+		const safeName = safeTokenName(token.name);
+		out.push({
+			name: token.name,
+			value: token.value,
+			valueType,
+			group: groupName,
+			namespace,
+			qualifiedName: namespace !== void 0 ? `${namespace}.${token.name}` : token.name,
+			safeName,
+			cssVar: buildCssVar(configPrefix, varPrefix, safeName),
+			modifiers: token.modifiers
+		});
+	}
+	return out;
+}
+/**
+* Resolve a style prop against the given resolved UDS config. Unknown group
+* refs are silently dropped from `tokens` (callers can detect this by
+* comparing input refs vs. resolved tokens if they need to surface a
+* config-build warning).
+*
+* @param propName - The JSX prop name (the map key from `registerStyleProps`).
+*/
+function resolveStyleProp(propName, styleProp, config) {
+	const { cssProperty, classPrefix, values, arbitrary, metadata } = styleProp;
+	const configPrefix = config.prefix;
+	const tokens = [];
+	const literals = [];
+	for (const entry of values ?? []) {
+		if (typeof entry === "string") {
+			const parsed = parseGroupRef(entry);
+			if (!parsed) {
+				literals.push(entry);
+				continue;
+			}
+			const group = findGroup(config.atomic, parsed.group);
+			if (!group) continue;
+			if (parsed.key !== void 0) {
+				const token = group.tokens.find((t) => t.name === parsed.key);
+				if (!token) continue;
+				const valueType = detectTokenValueType(token, group);
+				if (!isTokenAcceptedByProperty(cssProperty, valueType, token.value)) continue;
+				const safeName = safeTokenName(token.name);
+				const varPrefix = group.cssPrefix ?? group.namespace ?? parsed.group;
+				tokens.push({
+					name: token.name,
+					value: token.value,
+					valueType,
+					group: group.namespace ?? group.cssPrefix ?? parsed.group,
+					qualifiedName: token.name,
+					safeName,
+					cssVar: buildCssVar(configPrefix, varPrefix, safeName),
+					modifiers: token.modifiers
+				});
+			} else tokens.push(...resolveGroupTokens(group, cssProperty, configPrefix));
+			continue;
+		}
+		if (isNamespacedRef(entry)) {
+			const parsed = parseGroupRef(entry.ref);
+			if (!parsed || parsed.key !== void 0) continue;
+			const group = findGroup(config.atomic, parsed.group);
+			if (!group) continue;
+			tokens.push(...resolveGroupTokens(group, cssProperty, configPrefix, entry.namespace));
+		}
+	}
+	return {
+		propName,
+		cssProperty,
+		classPrefix,
+		tokens,
+		literals,
+		arbitrary,
+		metadata: metadata ?? {}
+	};
+}
+//#endregion
+export { resolveStyleProp };

package/dist/config/dist/types/css-values.d.ts

@@ -0,0 +1,61 @@
+//#region ../config/dist/types/css-values.d.ts
+//#region src/types/css-values.d.ts
+/**
+ * CSS value-type primitives — building blocks used by {@link CssPropertyValues}
+ * in `./css-properties` and by `defineStyleProp` to constrain authored values.
+ *
+ * Each entry in {@link CssValue} corresponds to a CSS value type name from the
+ * CSS specs (length, percentage, color, time, etc.). The CSS-wide keywords
+ * (`inherit`, `initial`, `unset`, `revert`) are bundled into {@link ColorKeyword}
+ * because color is the most common channel for them; properties that accept
+ * those keywords on non-color value types are expected to list them locally.
+ *
+ * Note: named colors (`red`, `blue`, etc.) are intentionally NOT in the union —
+ * authors should use a token, a hex code, or a function form (`rgb(...)`, etc.).
+ */
+/** CSS-wide keywords accepted on color-valued properties. */
+type ColorKeyword = 'transparent' | 'currentColor' | 'inherit' | 'initial' | 'unset' | 'revert';
+type HexColor = `#${string}`;
+type RgbColor = `rgb(${string})` | `rgba(${string})`;
+type HslColor = `hsl(${string})` | `hsla(${string})`;
+type ColorFn = `color(${string})` | `lab(${string})` | `lch(${string})` | `oklab(${string})` | `oklch(${string})`;
+type CssColor = HexColor | RgbColor | HslColor | ColorFn | ColorKeyword;
+type CssLength = `${number}px` | `${number}rem` | `${number}em` | `${number}ch` | `${number}ex` | `${number}vh` | `${number}vw` | `${number}vmin` | `${number}vmax` | 0;
+type CssPercentage = `${number}%`;
+type CssAngle = `${number}deg` | `${number}rad` | `${number}grad` | `${number}turn`;
+type CssTime = `${number}ms` | `${number}s`;
+type CssRatio = `${number}/${number}`;
+/**
+ * Registry of CSS value types, keyed by their spec-defined names.
+ *
+ * Used in two places:
+ *  1. As the source of truth for what shapes count as e.g. a "length" or a
+ *     "color" when validating token values and `defineStyleProp` `arbitrary`
+ *     specs.
+ *  2. By {@link import('./css-properties').CssPropertyValues}, which composes
+ *     these entries (plus per-property keywords) into the union accepted by
+ *     each CSS property.
+ */
+type CssValue = {
+  color: CssColor;
+  length: CssLength;
+  percentage: CssPercentage;
+  'length-percentage': CssLength | CssPercentage;
+  number: number;
+  integer: number;
+  angle: CssAngle;
+  time: CssTime;
+  ratio: CssRatio;
+  image: string;
+  url: `url(${string})`;
+  'font-weight': number | 'normal' | 'bold' | 'lighter' | 'bolder';
+  'font-family': string;
+  'easing-function': 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'step-start' | 'step-end' | `cubic-bezier(${string})` | `steps(${string})`;
+  shadow: string;
+  gradient: string;
+  ident: string;
+  string: string;
+};
+type CssValueTypeName = keyof CssValue; //#endregion
+//#endregion
+export { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, HexColor, HslColor, RgbColor };

package/dist/config.d.ts

@@ -1,13 +1,40 @@
 import { defaultColors } from "./config/dist/consts/defaultColors.js";
 import { TokenType, VarGroupDef, VarTokenDef, VarsConfig } from "./config/dist/types.js";
-import { GlobalStylesDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig } from "./config/dist/createConfig.js";
+import { GetModifierFromInput, GlobalStylesDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig } from "./config/dist/createConfig.js";
 import { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig } from "./config/dist/serialize.js";
 import { ComponentsConfig } from "./config/dist/index.js";
 import * as _$_uds_types0 from "@uds/types";
 
 //#region src/config.d.ts
 declare const uds: UdsConfig<_$_uds_types0.ModifierProp, {}, {}, {}, {}, never, {}>;
-declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "_dark" | "_sm" | "_md" | "_lg" | "_xl" | "_2xl", {
+declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | GetModifierFromInput<{
+  readonly colorMode: {
+    readonly options: {
+      readonly dark: {
+        readonly css: ".dark";
+      };
+    };
+  };
+  readonly responsive: {
+    readonly options: {
+      readonly sm: {
+        readonly media: "(min-width: 640px)";
+      };
+      readonly md: {
+        readonly media: "(min-width: 768px)";
+      };
+      readonly lg: {
+        readonly media: "(min-width: 1024px)";
+      };
+      readonly xl: {
+        readonly media: "(min-width: 1280px)";
+      };
+      readonly "2xl": {
+        readonly media: "(min-width: 1536px)";
+      };
+    };
+  };
+}>, {
   opacity: {
     0: string;
     5: string;
@@ -40,8 +67,8 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
   };
   rotate: {
     0: string;
-    2: string;
     1: string;
+    2: string;
     3: string;
     6: string;
     12: string;
@@ -195,16 +222,16 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
   spacing: {
     0: string;
     4: string;
-    2: string;
-    5: string;
     1: string;
     px: string;
+    2: string;
     8: string;
     0.5: string;
     1.5: string;
     2.5: string;
     3: string;
     3.5: string;
+    5: string;
     6: string;
     7: string;
     9: string;
@@ -238,30 +265,30 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
   outlineWidth: {
     0: string;
     4: string;
-    2: string;
     1: string;
+    2: string;
     8: string;
   };
   outlineOffset: {
     0: string;
     4: string;
-    2: string;
     1: string;
+    2: string;
     8: string;
   };
   ringWidth: {
     0: string;
     4: string;
     inset: string;
-    2: string;
     1: string;
+    2: string;
     8: string;
   };
   ringOffsetWidth: {
     0: string;
     4: string;
-    2: string;
     1: string;
+    2: string;
     8: string;
   };
   shadow: {
@@ -277,8 +304,8 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
   };
   strokeWidth: {
     0: string;
-    2: string;
     1: string;
+    2: string;
   };
   fontFamily: {
     sans: string;
@@ -289,9 +316,9 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
     normal: string;
     thin: string;
     bold: string;
-    light: string;
     medium: string;
     extralight: string;
+    light: string;
     semibold: string;
     extrabold: string;
     black: string;
@@ -331,20 +358,20 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
     0: string;
     4: string;
     full: string;
-    2: string;
-    5: string;
     1: string;
     "1/2": string;
     "1/3": string;
     "2/3": string;
     "1/4": string;
     "3/4": string;
+    2: string;
     8: string;
     0.5: string;
     1.5: string;
     2.5: string;
     3: string;
     3.5: string;
+    5: string;
     6: string;
     7: string;
     9: string;
@@ -386,13 +413,40 @@ declare const defaultPreset: UdsConfig<_$_uds_types0.ModifierProp | "_light" | "
   };
   skew: {
     0: string;
-    2: string;
     1: string;
+    2: string;
     3: string;
     6: string;
     12: string;
   };
-}, {}, {}, {}, "_light" | "_dark" | "_sm" | "_md" | "_lg" | "_xl" | "_2xl", {
+}, {}, {}, {}, GetModifierFromInput<{
+  readonly colorMode: {
+    readonly options: {
+      readonly dark: {
+        readonly css: ".dark";
+      };
+    };
+  };
+  readonly responsive: {
+    readonly options: {
+      readonly sm: {
+        readonly media: "(min-width: 640px)";
+      };
+      readonly md: {
+        readonly media: "(min-width: 768px)";
+      };
+      readonly lg: {
+        readonly media: "(min-width: 1024px)";
+      };
+      readonly xl: {
+        readonly media: "(min-width: 1280px)";
+      };
+      readonly "2xl": {
+        readonly media: "(min-width: 1536px)";
+      };
+    };
+  };
+}>, {
   readonly color: {
     readonly $type: "color";
     readonly inherit: {

package/dist/core/dist/compositeStyles.d.ts

@@ -1,7 +1,6 @@
 import { CompositeStylesConfig } from "@uds/types";
 
 //#region ../core/dist/compositeStyles.d.ts
-//#region src/compositeStyles.d.ts
 /** Set the composite-styles config (called by loader at build time) */
 declare function setCompositeStylesConfig(config: CompositeStylesConfig): void;
 /** Get the current composite-styles config */
@@ -17,6 +16,6 @@ declare function getCompositeStylesConfig(): CompositeStylesConfig;
 declare function expandCompositeStyles(props: Record<string, unknown>, config?: CompositeStylesConfig): {
   expanded: Record<string, unknown>;
   markerClasses: string[];
-}; //#endregion
+};
 //#endregion
 export { expandCompositeStyles, getCompositeStylesConfig, setCompositeStylesConfig };

package/dist/core/dist/createComponent.d.ts

@@ -1,7 +1,6 @@
 import { CreateComponentConfig, CreateComponentProps, CreateComponentRenderFn, CreateComponentSlotTagConfig, CreateComponentTypeInput } from "@uds/types";
 
 //#region ../core/dist/createComponent.d.ts
-//#region src/createComponent.d.ts
 type PrimitiveTag = keyof React.JSX.IntrinsicElements;
 type SpecConfig<TSpec> = TSpec extends {
   config: infer TConfig extends CreateComponentTypeInput;
@@ -52,6 +51,6 @@ declare function createComponent<TSpecOrProps = {}>(tag: PrimitiveTag): React.FC
   props: infer TOwnProps;
 } ? CreateComponentProps<TConfig, TOwnProps, PrimitiveTag> : PrimitiveOwnProps<TSpecOrProps>>;
 declare function createComponent<TSpec>(renderFn: CreateComponentRenderFn<SpecConfig<TSpec>, SpecOwnProps<TSpec>, SpecSlotConfig<TSpec>>): React.FC<CreateComponentProps<SpecConfig<TSpec>, SpecOwnProps<TSpec>, SpecSlotConfig<TSpec>>>;
-declare function createComponent(config: CreateComponentConfig<string>, renderFn: CreateComponentRenderFn<any, any, any>): React.FC<any>; //#endregion
+declare function createComponent(config: CreateComponentConfig<string>, renderFn: CreateComponentRenderFn<any, any, any>): React.FC<any>;
 //#endregion
 export { createComponent };

package/dist/core/dist/createComponentExample.d.ts

@@ -1,7 +1,6 @@
 import { ComponentProps, ComponentType } from "react";
 
 //#region ../core/dist/createComponentExample.d.ts
-//#region src/createComponentExample.d.ts
 /**
  * Extracts variant fixtures from a Component's props type.
  * If Button has `variant?: 'brand' | 'outline'` and `size?: 'sm' | 'md'`,
@@ -37,6 +36,6 @@ type ExamplesResult<TComponent extends ComponentType<any>> = {
  * }));
  * ```
  */
-declare function createComponentExample<TComponent extends ComponentType<any>, T extends Record<string, ExampleFn<TComponent>>>(Component: TComponent, examplesFn: (fixtures: VariantFixtures<TComponent>) => ExamplesResult<TComponent>): ComponentExample<T>; //#endregion
+declare function createComponentExample<TComponent extends ComponentType<any>, T extends Record<string, ExampleFn<TComponent>>>(Component: TComponent, examplesFn: (fixtures: VariantFixtures<TComponent>) => ExamplesResult<TComponent>): ComponentExample<T>;
 //#endregion
 export { ComponentExample, createComponentExample };

package/dist/core/dist/createProvider.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/createProvider.d.ts
-//#region src/createProvider.d.ts
 type ProviderRenderFn<TContext, TProps = Record<never, never>> = (props: {
   children: React.ReactNode;
 } & TProps) => {
@@ -8,6 +7,6 @@ type ProviderRenderFn<TContext, TProps = Record<never, never>> = (props: {
 };
 declare function createProvider<TContext, TProps = Record<never, never>>(name: string, renderFn: ProviderRenderFn<TContext, TProps>): [React.FC<{
   children: React.ReactNode;
-} & TProps>, () => TContext]; //#endregion
+} & TProps>, () => TContext];
 //#endregion
 export { createProvider };

package/dist/core/dist/generated/stylePropsTwMap.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/generated/stylePropsTwMap.d.ts
-//#region src/generated/stylePropsTwMap.d.ts
 declare const stylePropsTwMap: {
   readonly "border-boolean": {
     readonly border: "boolean";
@@ -1696,6 +1695,6 @@ declare const stylePropsTwMap: {
   readonly "hyphens-manual": {
     readonly hyphens: "manual";
   };
-}; //#endregion
+};
 //#endregion
 export { stylePropsTwMap };

package/dist/core/dist/getComponentStyles.d.ts

@@ -1,7 +1,6 @@
 import { ComponentRegistry, ComponentSlotsOf, ComponentVariantsOf } from "@uds/types";
 
 //#region ../core/dist/getComponentStyles.d.ts
-//#region src/getComponentStyles.d.ts
 type ResolveSlots<Name extends string> = Name extends keyof ComponentRegistry ? ComponentSlotsOf<Name> : string;
 type ResolveVariants<Name extends string> = Name extends keyof ComponentRegistry ? ComponentVariantsOf<Name> : Record<string, string>;
 interface UdsRuntimeMeta {
@@ -45,6 +44,6 @@ interface ComponentStyler<Name extends string> {
  * @param slots - Array of slot names
  * @param element - Optional HTML element tag for element-specific prop forwarding
  */
-declare function createComponentStyler<Name extends string>(componentName: Name, slots: readonly string[], element?: string, variants?: readonly string[]): ComponentStyler<Name>; //#endregion
+declare function createComponentStyler<Name extends string>(componentName: Name, slots: readonly string[], element?: string, variants?: readonly string[]): ComponentStyler<Name>;
 //#endregion
 export { createComponentStyler };

package/dist/core/dist/getStyles.d.ts

@@ -2,7 +2,6 @@ import { ClassValue } from "clsx";
 import { ModifierProp, ModifierProps, StyleAndModifierProps, StyleProps } from "@uds/types";
 
 //#region ../core/dist/getStyles.d.ts
-//#region src/getStyles.d.ts
 /** Convert kebab-case CSS property to camelCase for React inline styles.
  *  CSS custom properties (--*) are kept as-is since React supports them verbatim. */
 declare function toCamelCase(str: string): string;
@@ -38,6 +37,6 @@ interface GetStylesParams extends StyleProps, ModifierProps {
  *  so they can be included in the CSS safelist.
  */
 declare function getStyles(props: GetStylesParams): string;
-declare function getVariantClassName(componentName: string, variant: string | undefined): string; //#endregion
+declare function getVariantClassName(componentName: string, variant: string | undefined): string;
 //#endregion
 export { createVariants, cx, getStyles, getVariantClassName, processStyleProps, toCamelCase };

package/dist/core/dist/propMappings.d.ts

@@ -1,7 +1,6 @@
 import { ConfigurableProp, ModifierProp, StyleProp } from "@uds/types";
 
 //#region ../core/dist/propMappings.d.ts
-//#region src/propMappings.d.ts
 interface PropMapping {
   /** Class name prefix for runtime class generation. 'no-prefix' means value IS the class. */
   classPrefix: string;
@@ -72,6 +71,6 @@ interface ModifierEntry {
  *
  * e.g. `bg="primary"` + `bgOpacity="75"` → class `bg-primary_75`
  */
-declare const colorPropToOpacityProp: Record<string, string>; //#endregion
+declare const colorPropToOpacityProp: Record<string, string>;
 //#endregion
 export { ConfigurablePropertyEntry, CssVariablePrefixEntry, ModifierEntry, PropMapping, colorPropToOpacityProp, getConfigurablePropMapping, getConfigurableProperties, getCssVariablePrefixes, modifierMappings, propMappings };

package/dist/core/dist/resolveMotionState.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/resolveMotionState.d.ts
-//#region src/resolveMotionState.d.ts
-declare function resolveMotionState(stateKeyframe: Record<string, unknown>, index: number): Record<string, number>; //#endregion
+declare function resolveMotionState(stateKeyframe: Record<string, unknown>, index: number): Record<string, number>;
 //#endregion
 export { resolveMotionState };

package/dist/core/dist/transformPreset.d.ts

@@ -1,7 +1,6 @@
 import { MotionPreset } from "@uds/types";
 
 //#region ../core/dist/transformPreset.d.ts
-//#region src/transformPreset.d.ts
 interface TransformedMotionProps {
   initial?: Record<string, unknown>;
   animate?: Record<string, unknown>;
@@ -13,6 +12,6 @@ interface TransformedMotionProps {
 /**
  * Convert a JS-runtime MotionPreset to a motion/react-compatible props object.
  */
-declare function transformPreset(preset: MotionPreset): TransformedMotionProps; //#endregion
+declare function transformPreset(preset: MotionPreset): TransformedMotionProps;
 //#endregion
 export { TransformedMotionProps, transformPreset };

package/dist/core/dist/withDefaultStyleProps.d.ts

@@ -1,7 +1,6 @@
 import { BorderRadius, GridSpan, GridStartEnd, GridTemplate, StyleAndModifierProps } from "@uds/types";
 
 //#region ../core/dist/withDefaultStyleProps.d.ts
-//#region src/withDefaultStyleProps.d.ts
 interface StackDefaultsInput extends StyleAndModifierProps {
   gap?: StyleAndModifierProps['gap'];
 }
@@ -39,6 +38,6 @@ declare const withDefaultStyleProps: {
     shape?: BorderRadius;
   }) => StyleAndModifierProps;
   Svg: (props: SvgDefaultsInput) => StyleAndModifierProps;
-}; //#endregion
+};
 //#endregion
 export { withDefaultStyleProps };