@mekari/pixel3-styled-system 0.0.7 → 0.0.8-dev.0

package/recipes/index.d.ts

@@ -56,4 +56,5 @@ export * from './table-date-slot-recipe';
 export * from './table-month-slot-recipe';
 export * from './table-year-slot-recipe';
 export * from './pinbar-slot-recipe';
-export * from './carousel-slot-recipe';
+export * from './carousel-slot-recipe';
+export * from './chart-slot-recipe';

package/recipes/index.mjs

@@ -55,4 +55,5 @@ export * from './table-date-slot-recipe.mjs';
 export * from './table-month-slot-recipe.mjs';
 export * from './table-year-slot-recipe.mjs';
 export * from './pinbar-slot-recipe.mjs';
-export * from './carousel-slot-recipe.mjs';
+export * from './carousel-slot-recipe.mjs';
+export * from './chart-slot-recipe.mjs';

package/recipes/input-addon-slot-recipe.d.ts

@@ -22,6 +22,7 @@ export interface InputAddonSlotRecipeRecipe {
   variantMap: InputAddonSlotRecipeVariantMap
   variantKeys: Array<keyof InputAddonSlotRecipeVariant>
   splitVariantProps<Props extends InputAddonSlotRecipeVariantProps>(props: Props): [InputAddonSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputAddonSlotRecipeVariantProps>>]
+  getVariantProps: (props?: InputAddonSlotRecipeVariantProps) => InputAddonSlotRecipeVariantProps
 }
 
 

package/recipes/input-addon-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const inputAddonSlotRecipeDefaultVariants = {
@@ -16,13 +16,14 @@ const inputAddonSlotRecipeSlotNames = [
 const inputAddonSlotRecipeSlotFns = /* @__PURE__ */ inputAddonSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputAddonSlotRecipeDefaultVariants, getSlotCompoundVariant(inputAddonSlotRecipeCompoundVariants, slotName))])
 
 const inputAddonSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(inputAddonSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(inputAddonSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const inputAddonSlotRecipeVariantKeys = [
   "placement",
   "size"
 ]
+const getVariantProps = (variants) => ({ ...inputAddonSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const inputAddonSlotRecipe = /* @__PURE__ */ Object.assign(inputAddonSlotRecipeFn, {
   __recipe__: false,
@@ -42,4 +43,5 @@ export const inputAddonSlotRecipe = /* @__PURE__ */ Object.assign(inputAddonSlot
   splitVariantProps(props) {
     return splitProps(props, inputAddonSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/input-group-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface InputGroupSlotRecipeRecipe {
   variantMap: InputGroupSlotRecipeVariantMap
   variantKeys: Array<keyof InputGroupSlotRecipeVariant>
   splitVariantProps<Props extends InputGroupSlotRecipeVariantProps>(props: Props): [InputGroupSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputGroupSlotRecipeVariantProps>>]
+  getVariantProps: (props?: InputGroupSlotRecipeVariantProps) => InputGroupSlotRecipeVariantProps
 }
 
 

package/recipes/input-group-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const inputGroupSlotRecipeDefaultVariants = {}
@@ -13,10 +13,11 @@ const inputGroupSlotRecipeSlotNames = [
 const inputGroupSlotRecipeSlotFns = /* @__PURE__ */ inputGroupSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputGroupSlotRecipeDefaultVariants, getSlotCompoundVariant(inputGroupSlotRecipeCompoundVariants, slotName))])
 
 const inputGroupSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(inputGroupSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(inputGroupSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const inputGroupSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...inputGroupSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const inputGroupSlotRecipe = /* @__PURE__ */ Object.assign(inputGroupSlotRecipeFn, {
   __recipe__: false,
@@ -27,4 +28,5 @@ export const inputGroupSlotRecipe = /* @__PURE__ */ Object.assign(inputGroupSlot
   splitVariantProps(props) {
     return splitProps(props, inputGroupSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/input-slot-recipe.d.ts

@@ -22,6 +22,7 @@ export interface InputSlotRecipeRecipe {
   variantMap: InputSlotRecipeVariantMap
   variantKeys: Array<keyof InputSlotRecipeVariant>
   splitVariantProps<Props extends InputSlotRecipeVariantProps>(props: Props): [InputSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputSlotRecipeVariantProps>>]
+  getVariantProps: (props?: InputSlotRecipeVariantProps) => InputSlotRecipeVariantProps
 }
 
 

package/recipes/input-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const inputSlotRecipeDefaultVariants = {
@@ -24,13 +24,14 @@ const inputSlotRecipeSlotNames = [
 const inputSlotRecipeSlotFns = /* @__PURE__ */ inputSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputSlotRecipeDefaultVariants, getSlotCompoundVariant(inputSlotRecipeCompoundVariants, slotName))])
 
 const inputSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(inputSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(inputSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const inputSlotRecipeVariantKeys = [
   "variant",
   "size"
 ]
+const getVariantProps = (variants) => ({ ...inputSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const inputSlotRecipe = /* @__PURE__ */ Object.assign(inputSlotRecipeFn, {
   __recipe__: false,
@@ -50,4 +51,5 @@ export const inputSlotRecipe = /* @__PURE__ */ Object.assign(inputSlotRecipeFn,
   splitVariantProps(props) {
     return splitProps(props, inputSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/input-tag-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface InputTagSlotRecipeRecipe {
   variantMap: InputTagSlotRecipeVariantMap
   variantKeys: Array<keyof InputTagSlotRecipeVariant>
   splitVariantProps<Props extends InputTagSlotRecipeVariantProps>(props: Props): [InputTagSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputTagSlotRecipeVariantProps>>]
+  getVariantProps: (props?: InputTagSlotRecipeVariantProps) => InputTagSlotRecipeVariantProps
 }
 
 

package/recipes/input-tag-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const inputTagSlotRecipeDefaultVariants = {}
@@ -53,10 +53,11 @@ const inputTagSlotRecipeSlotNames = [
 const inputTagSlotRecipeSlotFns = /* @__PURE__ */ inputTagSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputTagSlotRecipeDefaultVariants, getSlotCompoundVariant(inputTagSlotRecipeCompoundVariants, slotName))])
 
 const inputTagSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(inputTagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(inputTagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const inputTagSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...inputTagSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const inputTagSlotRecipe = /* @__PURE__ */ Object.assign(inputTagSlotRecipeFn, {
   __recipe__: false,
@@ -67,4 +68,5 @@ export const inputTagSlotRecipe = /* @__PURE__ */ Object.assign(inputTagSlotReci
   splitVariantProps(props) {
     return splitProps(props, inputTagSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/modal-slot-recipe.d.ts

@@ -21,7 +21,12 @@ export interface ModalSlotRecipeRecipe {
   variantMap: ModalSlotRecipeVariantMap
   variantKeys: Array<keyof ModalSlotRecipeVariant>
   splitVariantProps<Props extends ModalSlotRecipeVariantProps>(props: Props): [ModalSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ModalSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ModalSlotRecipeVariantProps) => ModalSlotRecipeVariantProps
 }
 
-/** The styles for the Modal component */
+/**
+ * The styles for the Modal component
+
+
+ */
 export declare const modalSlotRecipe: ModalSlotRecipeRecipe

package/recipes/modal-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const modalSlotRecipeDefaultVariants = {
@@ -51,12 +51,13 @@ const modalSlotRecipeSlotNames = [
 const modalSlotRecipeSlotFns = /* @__PURE__ */ modalSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, modalSlotRecipeDefaultVariants, getSlotCompoundVariant(modalSlotRecipeCompoundVariants, slotName))])
 
 const modalSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(modalSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(modalSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const modalSlotRecipeVariantKeys = [
   "full"
 ]
+const getVariantProps = (variants) => ({ ...modalSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const modalSlotRecipe = /* @__PURE__ */ Object.assign(modalSlotRecipeFn, {
   __recipe__: false,
@@ -72,4 +73,5 @@ export const modalSlotRecipe = /* @__PURE__ */ Object.assign(modalSlotRecipeFn,
   splitVariantProps(props) {
     return splitProps(props, modalSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/month-item-recipe.d.ts

@@ -21,6 +21,7 @@ export interface MonthItemRecipeRecipe {
   variantMap: MonthItemRecipeVariantMap
   variantKeys: Array<keyof MonthItemRecipeVariant>
   splitVariantProps<Props extends MonthItemRecipeVariantProps>(props: Props): [MonthItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthItemRecipeVariantProps>>]
+  getVariantProps: (props?: MonthItemRecipeVariantProps) => MonthItemRecipeVariantProps
 }
 
 

package/recipes/month-item-recipe.mjs

@@ -15,9 +15,10 @@ const monthItemRecipeVariantMap = {
 
 const monthItemRecipeVariantKeys = Object.keys(monthItemRecipeVariantMap)
 
-export const monthItemRecipe = /* @__PURE__ */ Object.assign(memo(monthItemRecipeFn), {
+export const monthItemRecipe = /* @__PURE__ */ Object.assign(memo(monthItemRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'monthItemRecipe',
+  __getCompoundVariantCss__: monthItemRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: monthItemRecipeVariantKeys,
   variantMap: monthItemRecipeVariantMap,
@@ -27,4 +28,5 @@ export const monthItemRecipe = /* @__PURE__ */ Object.assign(memo(monthItemRecip
   splitVariantProps(props) {
     return splitProps(props, monthItemRecipeVariantKeys)
   },
+  getVariantProps: monthItemRecipeFn.getVariantProps,
 })

package/recipes/pinbar-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface PinbarSlotRecipeRecipe {
   variantMap: PinbarSlotRecipeVariantMap
   variantKeys: Array<keyof PinbarSlotRecipeVariant>
   splitVariantProps<Props extends PinbarSlotRecipeVariantProps>(props: Props): [PinbarSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PinbarSlotRecipeVariantProps>>]
+  getVariantProps: (props?: PinbarSlotRecipeVariantProps) => PinbarSlotRecipeVariantProps
 }
 
 

package/recipes/pinbar-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const pinbarSlotRecipeDefaultVariants = {}
@@ -17,10 +17,11 @@ const pinbarSlotRecipeSlotNames = [
 const pinbarSlotRecipeSlotFns = /* @__PURE__ */ pinbarSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, pinbarSlotRecipeDefaultVariants, getSlotCompoundVariant(pinbarSlotRecipeCompoundVariants, slotName))])
 
 const pinbarSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(pinbarSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(pinbarSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const pinbarSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...pinbarSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const pinbarSlotRecipe = /* @__PURE__ */ Object.assign(pinbarSlotRecipeFn, {
   __recipe__: false,
@@ -31,4 +32,5 @@ export const pinbarSlotRecipe = /* @__PURE__ */ Object.assign(pinbarSlotRecipeFn
   splitVariantProps(props) {
     return splitProps(props, pinbarSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/popover-content-recipe.d.ts

@@ -22,6 +22,7 @@ export interface PopoverContentRecipeRecipe {
   variantMap: PopoverContentRecipeVariantMap
   variantKeys: Array<keyof PopoverContentRecipeVariant>
   splitVariantProps<Props extends PopoverContentRecipeVariantProps>(props: Props): [PopoverContentRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverContentRecipeVariantProps>>]
+  getVariantProps: (props?: PopoverContentRecipeVariantProps) => PopoverContentRecipeVariantProps
 }
 
 

package/recipes/popover-content-recipe.mjs

@@ -19,9 +19,10 @@ const popoverContentRecipeVariantMap = {
 
 const popoverContentRecipeVariantKeys = Object.keys(popoverContentRecipeVariantMap)
 
-export const popoverContentRecipe = /* @__PURE__ */ Object.assign(memo(popoverContentRecipeFn), {
+export const popoverContentRecipe = /* @__PURE__ */ Object.assign(memo(popoverContentRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'popoverContentRecipe',
+  __getCompoundVariantCss__: popoverContentRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: popoverContentRecipeVariantKeys,
   variantMap: popoverContentRecipeVariantMap,
@@ -31,4 +32,5 @@ export const popoverContentRecipe = /* @__PURE__ */ Object.assign(memo(popoverCo
   splitVariantProps(props) {
     return splitProps(props, popoverContentRecipeVariantKeys)
   },
+  getVariantProps: popoverContentRecipeFn.getVariantProps,
 })

package/recipes/popover-list-item-recipe.d.ts

@@ -21,6 +21,7 @@ export interface PopoverListItemRecipeRecipe {
   variantMap: PopoverListItemRecipeVariantMap
   variantKeys: Array<keyof PopoverListItemRecipeVariant>
   splitVariantProps<Props extends PopoverListItemRecipeVariantProps>(props: Props): [PopoverListItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverListItemRecipeVariantProps>>]
+  getVariantProps: (props?: PopoverListItemRecipeVariantProps) => PopoverListItemRecipeVariantProps
 }
 
 

package/recipes/popover-list-item-recipe.mjs

@@ -7,9 +7,10 @@ const popoverListItemRecipeVariantMap = {}
 
 const popoverListItemRecipeVariantKeys = Object.keys(popoverListItemRecipeVariantMap)
 
-export const popoverListItemRecipe = /* @__PURE__ */ Object.assign(memo(popoverListItemRecipeFn), {
+export const popoverListItemRecipe = /* @__PURE__ */ Object.assign(memo(popoverListItemRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'popoverListItemRecipe',
+  __getCompoundVariantCss__: popoverListItemRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: popoverListItemRecipeVariantKeys,
   variantMap: popoverListItemRecipeVariantMap,
@@ -19,4 +20,5 @@ export const popoverListItemRecipe = /* @__PURE__ */ Object.assign(memo(popoverL
   splitVariantProps(props) {
     return splitProps(props, popoverListItemRecipeVariantKeys)
   },
+  getVariantProps: popoverListItemRecipeFn.getVariantProps,
 })

package/recipes/popover-list-recipe.d.ts

@@ -21,6 +21,7 @@ export interface PopoverListRecipeRecipe {
   variantMap: PopoverListRecipeVariantMap
   variantKeys: Array<keyof PopoverListRecipeVariant>
   splitVariantProps<Props extends PopoverListRecipeVariantProps>(props: Props): [PopoverListRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverListRecipeVariantProps>>]
+  getVariantProps: (props?: PopoverListRecipeVariantProps) => PopoverListRecipeVariantProps
 }
 
 

package/recipes/popover-list-recipe.mjs

@@ -7,9 +7,10 @@ const popoverListRecipeVariantMap = {}
 
 const popoverListRecipeVariantKeys = Object.keys(popoverListRecipeVariantMap)
 
-export const popoverListRecipe = /* @__PURE__ */ Object.assign(memo(popoverListRecipeFn), {
+export const popoverListRecipe = /* @__PURE__ */ Object.assign(memo(popoverListRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'popoverListRecipe',
+  __getCompoundVariantCss__: popoverListRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: popoverListRecipeVariantKeys,
   variantMap: popoverListRecipeVariantMap,
@@ -19,4 +20,5 @@ export const popoverListRecipe = /* @__PURE__ */ Object.assign(memo(popoverListR
   splitVariantProps(props) {
     return splitProps(props, popoverListRecipeVariantKeys)
   },
+  getVariantProps: popoverListRecipeFn.getVariantProps,
 })

package/recipes/progress-slot-recipe.d.ts

@@ -22,6 +22,7 @@ export interface ProgressSlotRecipeRecipe {
   variantMap: ProgressSlotRecipeVariantMap
   variantKeys: Array<keyof ProgressSlotRecipeVariant>
   splitVariantProps<Props extends ProgressSlotRecipeVariantProps>(props: Props): [ProgressSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ProgressSlotRecipeVariantProps) => ProgressSlotRecipeVariantProps
 }
 
 

package/recipes/progress-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const progressSlotRecipeDefaultVariants = {
@@ -28,13 +28,14 @@ const progressSlotRecipeSlotNames = [
 const progressSlotRecipeSlotFns = /* @__PURE__ */ progressSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressSlotRecipeDefaultVariants, getSlotCompoundVariant(progressSlotRecipeCompoundVariants, slotName))])
 
 const progressSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(progressSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(progressSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const progressSlotRecipeVariantKeys = [
   "size",
   "variant"
 ]
+const getVariantProps = (variants) => ({ ...progressSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const progressSlotRecipe = /* @__PURE__ */ Object.assign(progressSlotRecipeFn, {
   __recipe__: false,
@@ -54,4 +55,5 @@ export const progressSlotRecipe = /* @__PURE__ */ Object.assign(progressSlotReci
   splitVariantProps(props) {
     return splitProps(props, progressSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/radio-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface RadioSlotRecipeRecipe {
   variantMap: RadioSlotRecipeVariantMap
   variantKeys: Array<keyof RadioSlotRecipeVariant>
   splitVariantProps<Props extends RadioSlotRecipeVariantProps>(props: Props): [RadioSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof RadioSlotRecipeVariantProps>>]
+  getVariantProps: (props?: RadioSlotRecipeVariantProps) => RadioSlotRecipeVariantProps
 }
 
 

package/recipes/radio-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const radioSlotRecipeDefaultVariants = {}
@@ -21,10 +21,11 @@ const radioSlotRecipeSlotNames = [
 const radioSlotRecipeSlotFns = /* @__PURE__ */ radioSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioSlotRecipeDefaultVariants, getSlotCompoundVariant(radioSlotRecipeCompoundVariants, slotName))])
 
 const radioSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(radioSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(radioSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const radioSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...radioSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const radioSlotRecipe = /* @__PURE__ */ Object.assign(radioSlotRecipeFn, {
   __recipe__: false,
@@ -35,4 +36,5 @@ export const radioSlotRecipe = /* @__PURE__ */ Object.assign(radioSlotRecipeFn,
   splitVariantProps(props) {
     return splitProps(props, radioSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/rich-text-editor-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface RichTextEditorSlotRecipeRecipe {
   variantMap: RichTextEditorSlotRecipeVariantMap
   variantKeys: Array<keyof RichTextEditorSlotRecipeVariant>
   splitVariantProps<Props extends RichTextEditorSlotRecipeVariantProps>(props: Props): [RichTextEditorSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof RichTextEditorSlotRecipeVariantProps>>]
+  getVariantProps: (props?: RichTextEditorSlotRecipeVariantProps) => RichTextEditorSlotRecipeVariantProps
 }
 
 

package/recipes/rich-text-editor-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const richTextEditorSlotRecipeDefaultVariants = {}
@@ -21,10 +21,11 @@ const richTextEditorSlotRecipeSlotNames = [
 const richTextEditorSlotRecipeSlotFns = /* @__PURE__ */ richTextEditorSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, richTextEditorSlotRecipeDefaultVariants, getSlotCompoundVariant(richTextEditorSlotRecipeCompoundVariants, slotName))])
 
 const richTextEditorSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(richTextEditorSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(richTextEditorSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const richTextEditorSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...richTextEditorSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const richTextEditorSlotRecipe = /* @__PURE__ */ Object.assign(richTextEditorSlotRecipeFn, {
   __recipe__: false,
@@ -35,4 +36,5 @@ export const richTextEditorSlotRecipe = /* @__PURE__ */ Object.assign(richTextEd
   splitVariantProps(props) {
     return splitProps(props, richTextEditorSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/rtestyle-provider-recipe.d.ts

@@ -21,6 +21,7 @@ export interface RTEStyleProviderRecipeRecipe {
   variantMap: RTEStyleProviderRecipeVariantMap
   variantKeys: Array<keyof RTEStyleProviderRecipeVariant>
   splitVariantProps<Props extends RTEStyleProviderRecipeVariantProps>(props: Props): [RTEStyleProviderRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof RTEStyleProviderRecipeVariantProps>>]
+  getVariantProps: (props?: RTEStyleProviderRecipeVariantProps) => RTEStyleProviderRecipeVariantProps
 }
 
 

package/recipes/rtestyle-provider-recipe.mjs

@@ -7,9 +7,10 @@ const RTEStyleProviderRecipeVariantMap = {}
 
 const RTEStyleProviderRecipeVariantKeys = Object.keys(RTEStyleProviderRecipeVariantMap)
 
-export const RTEStyleProviderRecipe = /* @__PURE__ */ Object.assign(memo(RTEStyleProviderRecipeFn), {
+export const RTEStyleProviderRecipe = /* @__PURE__ */ Object.assign(memo(RTEStyleProviderRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'RTEStyleProviderRecipe',
+  __getCompoundVariantCss__: RTEStyleProviderRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: RTEStyleProviderRecipeVariantKeys,
   variantMap: RTEStyleProviderRecipeVariantMap,
@@ -19,4 +20,5 @@ export const RTEStyleProviderRecipe = /* @__PURE__ */ Object.assign(memo(RTEStyl
   splitVariantProps(props) {
     return splitProps(props, RTEStyleProviderRecipeVariantKeys)
   },
+  getVariantProps: RTEStyleProviderRecipeFn.getVariantProps,
 })

package/recipes/segmented-control-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface SegmentedControlSlotRecipeRecipe {
   variantMap: SegmentedControlSlotRecipeVariantMap
   variantKeys: Array<keyof SegmentedControlSlotRecipeVariant>
   splitVariantProps<Props extends SegmentedControlSlotRecipeVariantProps>(props: Props): [SegmentedControlSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SegmentedControlSlotRecipeVariantProps>>]
+  getVariantProps: (props?: SegmentedControlSlotRecipeVariantProps) => SegmentedControlSlotRecipeVariantProps
 }
 
 

package/recipes/segmented-control-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const segmentedControlSlotRecipeDefaultVariants = {}
@@ -33,10 +33,11 @@ const segmentedControlSlotRecipeSlotNames = [
 const segmentedControlSlotRecipeSlotFns = /* @__PURE__ */ segmentedControlSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, segmentedControlSlotRecipeDefaultVariants, getSlotCompoundVariant(segmentedControlSlotRecipeCompoundVariants, slotName))])
 
 const segmentedControlSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(segmentedControlSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(segmentedControlSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const segmentedControlSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...segmentedControlSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const segmentedControlSlotRecipe = /* @__PURE__ */ Object.assign(segmentedControlSlotRecipeFn, {
   __recipe__: false,
@@ -47,4 +48,5 @@ export const segmentedControlSlotRecipe = /* @__PURE__ */ Object.assign(segmente
   splitVariantProps(props) {
     return splitProps(props, segmentedControlSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/select-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface SelectSlotRecipeRecipe {
   variantMap: SelectSlotRecipeVariantMap
   variantKeys: Array<keyof SelectSlotRecipeVariant>
   splitVariantProps<Props extends SelectSlotRecipeVariantProps>(props: Props): [SelectSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SelectSlotRecipeVariantProps>>]
+  getVariantProps: (props?: SelectSlotRecipeVariantProps) => SelectSlotRecipeVariantProps
 }
 
 

package/recipes/select-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const selectSlotRecipeDefaultVariants = {
@@ -27,12 +27,13 @@ const selectSlotRecipeSlotNames = [
 const selectSlotRecipeSlotFns = /* @__PURE__ */ selectSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, selectSlotRecipeDefaultVariants, getSlotCompoundVariant(selectSlotRecipeCompoundVariants, slotName))])
 
 const selectSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(selectSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(selectSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const selectSlotRecipeVariantKeys = [
   "size"
 ]
+const getVariantProps = (variants) => ({ ...selectSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const selectSlotRecipe = /* @__PURE__ */ Object.assign(selectSlotRecipeFn, {
   __recipe__: false,
@@ -48,4 +49,5 @@ export const selectSlotRecipe = /* @__PURE__ */ Object.assign(selectSlotRecipeFn
   splitVariantProps(props) {
     return splitProps(props, selectSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/selected-border-recipe.d.ts

@@ -22,6 +22,7 @@ export interface SelectedBorderRecipeRecipe {
   variantMap: SelectedBorderRecipeVariantMap
   variantKeys: Array<keyof SelectedBorderRecipeVariant>
   splitVariantProps<Props extends SelectedBorderRecipeVariantProps>(props: Props): [SelectedBorderRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SelectedBorderRecipeVariantProps>>]
+  getVariantProps: (props?: SelectedBorderRecipeVariantProps) => SelectedBorderRecipeVariantProps
 }
 
 

package/recipes/selected-border-recipe.mjs

@@ -73,9 +73,10 @@ const selectedBorderRecipeVariantMap = {
 
 const selectedBorderRecipeVariantKeys = Object.keys(selectedBorderRecipeVariantMap)
 
-export const selectedBorderRecipe = /* @__PURE__ */ Object.assign(memo(selectedBorderRecipeFn), {
+export const selectedBorderRecipe = /* @__PURE__ */ Object.assign(memo(selectedBorderRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'selectedBorderRecipe',
+  __getCompoundVariantCss__: selectedBorderRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: selectedBorderRecipeVariantKeys,
   variantMap: selectedBorderRecipeVariantMap,
@@ -85,4 +86,5 @@ export const selectedBorderRecipe = /* @__PURE__ */ Object.assign(memo(selectedB
   splitVariantProps(props) {
     return splitProps(props, selectedBorderRecipeVariantKeys)
   },
+  getVariantProps: selectedBorderRecipeFn.getVariantProps,
 })

package/recipes/shared-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface SharedSlotRecipeRecipe {
   variantMap: SharedSlotRecipeVariantMap
   variantKeys: Array<keyof SharedSlotRecipeVariant>
   splitVariantProps<Props extends SharedSlotRecipeVariantProps>(props: Props): [SharedSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SharedSlotRecipeVariantProps>>]
+  getVariantProps: (props?: SharedSlotRecipeVariantProps) => SharedSlotRecipeVariantProps
 }
 
 

package/recipes/shared-slot-recipe.mjs

@@ -1,4 +1,4 @@
-import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
 import { createRecipe } from './create-recipe.mjs';
 
 const sharedSlotRecipeDefaultVariants = {}
@@ -13,10 +13,11 @@ const sharedSlotRecipeSlotNames = [
 const sharedSlotRecipeSlotFns = /* @__PURE__ */ sharedSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sharedSlotRecipeDefaultVariants, getSlotCompoundVariant(sharedSlotRecipeCompoundVariants, slotName))])
 
 const sharedSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(sharedSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(sharedSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const sharedSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...sharedSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const sharedSlotRecipe = /* @__PURE__ */ Object.assign(sharedSlotRecipeFn, {
   __recipe__: false,
@@ -27,4 +28,5 @@ export const sharedSlotRecipe = /* @__PURE__ */ Object.assign(sharedSlotRecipeFn
   splitVariantProps(props) {
     return splitProps(props, sharedSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/spinner-recipe.d.ts

@@ -21,6 +21,7 @@ export interface SpinnerRecipeRecipe {
   variantMap: SpinnerRecipeVariantMap
   variantKeys: Array<keyof SpinnerRecipeVariant>
   splitVariantProps<Props extends SpinnerRecipeVariantProps>(props: Props): [SpinnerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SpinnerRecipeVariantProps>>]
+  getVariantProps: (props?: SpinnerRecipeVariantProps) => SpinnerRecipeVariantProps
 }