@mekari/pixel3-styled-system 0.0.7 → 0.0.8

package/recipes/spinner-recipe.mjs

@@ -14,9 +14,10 @@ const spinnerRecipeVariantMap = {
 
 const spinnerRecipeVariantKeys = Object.keys(spinnerRecipeVariantMap)
 
-export const spinnerRecipe = /* @__PURE__ */ Object.assign(memo(spinnerRecipeFn), {
+export const spinnerRecipe = /* @__PURE__ */ Object.assign(memo(spinnerRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'spinnerRecipe',
+  __getCompoundVariantCss__: spinnerRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: spinnerRecipeVariantKeys,
   variantMap: spinnerRecipeVariantMap,
@@ -26,4 +27,5 @@ export const spinnerRecipe = /* @__PURE__ */ Object.assign(memo(spinnerRecipeFn)
   splitVariantProps(props) {
     return splitProps(props, spinnerRecipeVariantKeys)
   },
+  getVariantProps: spinnerRecipeFn.getVariantProps,
 })

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

@@ -21,6 +21,7 @@ export interface TabListRecipeRecipe {
   variantMap: TabListRecipeVariantMap
   variantKeys: Array<keyof TabListRecipeVariant>
   splitVariantProps<Props extends TabListRecipeVariantProps>(props: Props): [TabListRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabListRecipeVariantProps>>]
+  getVariantProps: (props?: TabListRecipeVariantProps) => TabListRecipeVariantProps
 }
 
 

package/recipes/tab-list-recipe.mjs

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

package/recipes/tab-recipe.d.ts

@@ -22,6 +22,7 @@ export interface TabRecipeRecipe {
   variantMap: TabRecipeVariantMap
   variantKeys: Array<keyof TabRecipeVariant>
   splitVariantProps<Props extends TabRecipeVariantProps>(props: Props): [TabRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabRecipeVariantProps>>]
+  getVariantProps: (props?: TabRecipeVariantProps) => TabRecipeVariantProps
 }
 
 

package/recipes/tab-recipe.mjs

@@ -72,9 +72,10 @@ const tabRecipeVariantMap = {
 
 const tabRecipeVariantKeys = Object.keys(tabRecipeVariantMap)
 
-export const tabRecipe = /* @__PURE__ */ Object.assign(memo(tabRecipeFn), {
+export const tabRecipe = /* @__PURE__ */ Object.assign(memo(tabRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'tabRecipe',
+  __getCompoundVariantCss__: tabRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: tabRecipeVariantKeys,
   variantMap: tabRecipeVariantMap,
@@ -84,4 +85,5 @@ export const tabRecipe = /* @__PURE__ */ Object.assign(memo(tabRecipeFn), {
   splitVariantProps(props) {
     return splitProps(props, tabRecipeVariantKeys)
   },
+  getVariantProps: tabRecipeFn.getVariantProps,
 })

package/recipes/table-container-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TableContainerRecipeRecipe {
   variantMap: TableContainerRecipeVariantMap
   variantKeys: Array<keyof TableContainerRecipeVariant>
   splitVariantProps<Props extends TableContainerRecipeVariantProps>(props: Props): [TableContainerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableContainerRecipeVariantProps>>]
+  getVariantProps: (props?: TableContainerRecipeVariantProps) => TableContainerRecipeVariantProps
 }
 
 

package/recipes/table-container-recipe.mjs

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

package/recipes/table-date-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TableDateSlotRecipeRecipe {
   variantMap: TableDateSlotRecipeVariantMap
   variantKeys: Array<keyof TableDateSlotRecipeVariant>
   splitVariantProps<Props extends TableDateSlotRecipeVariantProps>(props: Props): [TableDateSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableDateSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TableDateSlotRecipeVariantProps) => TableDateSlotRecipeVariantProps
 }
 
 

package/recipes/table-date-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 tableDateSlotRecipeDefaultVariants = {}
@@ -33,10 +33,11 @@ const tableDateSlotRecipeSlotNames = [
 const tableDateSlotRecipeSlotFns = /* @__PURE__ */ tableDateSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableDateSlotRecipeDefaultVariants, getSlotCompoundVariant(tableDateSlotRecipeCompoundVariants, slotName))])
 
 const tableDateSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(tableDateSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(tableDateSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const tableDateSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...tableDateSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const tableDateSlotRecipe = /* @__PURE__ */ Object.assign(tableDateSlotRecipeFn, {
   __recipe__: false,
@@ -47,4 +48,5 @@ export const tableDateSlotRecipe = /* @__PURE__ */ Object.assign(tableDateSlotRe
   splitVariantProps(props) {
     return splitProps(props, tableDateSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/table-month-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TableMonthSlotRecipeRecipe {
   variantMap: TableMonthSlotRecipeVariantMap
   variantKeys: Array<keyof TableMonthSlotRecipeVariant>
   splitVariantProps<Props extends TableMonthSlotRecipeVariantProps>(props: Props): [TableMonthSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableMonthSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TableMonthSlotRecipeVariantProps) => TableMonthSlotRecipeVariantProps
 }
 
 

package/recipes/table-month-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 tableMonthSlotRecipeDefaultVariants = {}
@@ -29,10 +29,11 @@ const tableMonthSlotRecipeSlotNames = [
 const tableMonthSlotRecipeSlotFns = /* @__PURE__ */ tableMonthSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableMonthSlotRecipeDefaultVariants, getSlotCompoundVariant(tableMonthSlotRecipeCompoundVariants, slotName))])
 
 const tableMonthSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(tableMonthSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(tableMonthSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const tableMonthSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...tableMonthSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const tableMonthSlotRecipe = /* @__PURE__ */ Object.assign(tableMonthSlotRecipeFn, {
   __recipe__: false,
@@ -43,4 +44,5 @@ export const tableMonthSlotRecipe = /* @__PURE__ */ Object.assign(tableMonthSlot
   splitVariantProps(props) {
     return splitProps(props, tableMonthSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/table-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TableRecipeRecipe {
   variantMap: TableRecipeVariantMap
   variantKeys: Array<keyof TableRecipeVariant>
   splitVariantProps<Props extends TableRecipeVariantProps>(props: Props): [TableRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableRecipeVariantProps>>]
+  getVariantProps: (props?: TableRecipeVariantProps) => TableRecipeVariantProps
 }
 
 

package/recipes/table-recipe.mjs

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

package/recipes/table-year-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TableYearSlotRecipeRecipe {
   variantMap: TableYearSlotRecipeVariantMap
   variantKeys: Array<keyof TableYearSlotRecipeVariant>
   splitVariantProps<Props extends TableYearSlotRecipeVariantProps>(props: Props): [TableYearSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableYearSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TableYearSlotRecipeVariantProps) => TableYearSlotRecipeVariantProps
 }
 
 

package/recipes/table-year-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 tableYearSlotRecipeDefaultVariants = {}
@@ -29,10 +29,11 @@ const tableYearSlotRecipeSlotNames = [
 const tableYearSlotRecipeSlotFns = /* @__PURE__ */ tableYearSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableYearSlotRecipeDefaultVariants, getSlotCompoundVariant(tableYearSlotRecipeCompoundVariants, slotName))])
 
 const tableYearSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(tableYearSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(tableYearSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const tableYearSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...tableYearSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const tableYearSlotRecipe = /* @__PURE__ */ Object.assign(tableYearSlotRecipeFn, {
   __recipe__: false,
@@ -43,4 +44,5 @@ export const tableYearSlotRecipe = /* @__PURE__ */ Object.assign(tableYearSlotRe
   splitVariantProps(props) {
     return splitProps(props, tableYearSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

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

@@ -22,6 +22,7 @@ export interface TagSlotRecipeRecipe {
   variantMap: TagSlotRecipeVariantMap
   variantKeys: Array<keyof TagSlotRecipeVariant>
   splitVariantProps<Props extends TagSlotRecipeVariantProps>(props: Props): [TagSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TagSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TagSlotRecipeVariantProps) => TagSlotRecipeVariantProps
 }
 
 

package/recipes/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 tagSlotRecipeDefaultVariants = {
@@ -45,13 +45,14 @@ const tagSlotRecipeSlotNames = [
 const tagSlotRecipeSlotFns = /* @__PURE__ */ tagSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tagSlotRecipeDefaultVariants, getSlotCompoundVariant(tagSlotRecipeCompoundVariants, slotName))])
 
 const tagSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(tagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(tagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const tagSlotRecipeVariantKeys = [
   "size",
   "variant"
 ]
+const getVariantProps = (variants) => ({ ...tagSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const tagSlotRecipe = /* @__PURE__ */ Object.assign(tagSlotRecipeFn, {
   __recipe__: false,
@@ -71,4 +72,5 @@ export const tagSlotRecipe = /* @__PURE__ */ Object.assign(tagSlotRecipeFn, {
   splitVariantProps(props) {
     return splitProps(props, tagSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/text-recipe.d.ts

@@ -22,6 +22,7 @@ export interface TextRecipeRecipe {
   variantMap: TextRecipeVariantMap
   variantKeys: Array<keyof TextRecipeVariant>
   splitVariantProps<Props extends TextRecipeVariantProps>(props: Props): [TextRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TextRecipeVariantProps>>]
+  getVariantProps: (props?: TextRecipeVariantProps) => TextRecipeVariantProps
 }
 
 

package/recipes/text-recipe.mjs

@@ -25,9 +25,10 @@ const textRecipeVariantMap = {
 
 const textRecipeVariantKeys = Object.keys(textRecipeVariantMap)
 
-export const textRecipe = /* @__PURE__ */ Object.assign(memo(textRecipeFn), {
+export const textRecipe = /* @__PURE__ */ Object.assign(memo(textRecipeFn.recipeFn), {
   __recipe__: true,
   __name__: 'textRecipe',
+  __getCompoundVariantCss__: textRecipeFn.__getCompoundVariantCss__,
   raw: (props) => props,
   variantKeys: textRecipeVariantKeys,
   variantMap: textRecipeVariantMap,
@@ -37,4 +38,5 @@ export const textRecipe = /* @__PURE__ */ Object.assign(memo(textRecipeFn), {
   splitVariantProps(props) {
     return splitProps(props, textRecipeVariantKeys)
   },
+  getVariantProps: textRecipeFn.getVariantProps,
 })

package/recipes/textarea-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TextareaRecipeRecipe {
   variantMap: TextareaRecipeVariantMap
   variantKeys: Array<keyof TextareaRecipeVariant>
   splitVariantProps<Props extends TextareaRecipeVariantProps>(props: Props): [TextareaRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TextareaRecipeVariantProps>>]
+  getVariantProps: (props?: TextareaRecipeVariantProps) => TextareaRecipeVariantProps
 }
 
 

package/recipes/textarea-recipe.mjs

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

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

@@ -21,6 +21,7 @@ export interface ToastSlotRecipeRecipe {
   variantMap: ToastSlotRecipeVariantMap
   variantKeys: Array<keyof ToastSlotRecipeVariant>
   splitVariantProps<Props extends ToastSlotRecipeVariantProps>(props: Props): [ToastSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ToastSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ToastSlotRecipeVariantProps) => ToastSlotRecipeVariantProps
 }
 
 

package/recipes/toast-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 toastSlotRecipeDefaultVariants = {
@@ -40,12 +40,13 @@ const toastSlotRecipeSlotNames = [
 const toastSlotRecipeSlotFns = /* @__PURE__ */ toastSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toastSlotRecipeDefaultVariants, getSlotCompoundVariant(toastSlotRecipeCompoundVariants, slotName))])
 
 const toastSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(toastSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(toastSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const toastSlotRecipeVariantKeys = [
   "variant"
 ]
+const getVariantProps = (variants) => ({ ...toastSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const toastSlotRecipe = /* @__PURE__ */ Object.assign(toastSlotRecipeFn, {
   __recipe__: false,
@@ -61,4 +62,5 @@ export const toastSlotRecipe = /* @__PURE__ */ Object.assign(toastSlotRecipeFn,
   splitVariantProps(props) {
     return splitProps(props, toastSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

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

@@ -21,6 +21,7 @@ export interface ToggleSlotRecipeRecipe {
   variantMap: ToggleSlotRecipeVariantMap
   variantKeys: Array<keyof ToggleSlotRecipeVariant>
   splitVariantProps<Props extends ToggleSlotRecipeVariantProps>(props: Props): [ToggleSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ToggleSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ToggleSlotRecipeVariantProps) => ToggleSlotRecipeVariantProps
 }
 
 

package/recipes/toggle-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 toggleSlotRecipeDefaultVariants = {}
@@ -21,10 +21,11 @@ const toggleSlotRecipeSlotNames = [
 const toggleSlotRecipeSlotFns = /* @__PURE__ */ toggleSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toggleSlotRecipeDefaultVariants, getSlotCompoundVariant(toggleSlotRecipeCompoundVariants, slotName))])
 
 const toggleSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(toggleSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(toggleSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const toggleSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...toggleSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const toggleSlotRecipe = /* @__PURE__ */ Object.assign(toggleSlotRecipeFn, {
   __recipe__: false,
@@ -35,4 +36,5 @@ export const toggleSlotRecipe = /* @__PURE__ */ Object.assign(toggleSlotRecipeFn
   splitVariantProps(props) {
     return splitProps(props, toggleSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

package/recipes/tooltip-recipe.d.ts

@@ -21,6 +21,7 @@ export interface TooltipRecipeRecipe {
   variantMap: TooltipRecipeVariantMap
   variantKeys: Array<keyof TooltipRecipeVariant>
   splitVariantProps<Props extends TooltipRecipeVariantProps>(props: Props): [TooltipRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TooltipRecipeVariantProps>>]
+  getVariantProps: (props?: TooltipRecipeVariantProps) => TooltipRecipeVariantProps
 }
 
 

package/recipes/tooltip-recipe.mjs

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

package/recipes/upload-list-slot-recipe.d.ts

@@ -21,6 +21,7 @@ export interface UploadListSlotRecipeRecipe {
   variantMap: UploadListSlotRecipeVariantMap
   variantKeys: Array<keyof UploadListSlotRecipeVariant>
   splitVariantProps<Props extends UploadListSlotRecipeVariantProps>(props: Props): [UploadListSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof UploadListSlotRecipeVariantProps>>]
+  getVariantProps: (props?: UploadListSlotRecipeVariantProps) => UploadListSlotRecipeVariantProps
 }
 
 

package/recipes/upload-list-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 uploadListSlotRecipeDefaultVariants = {}
@@ -21,10 +21,11 @@ const uploadListSlotRecipeSlotNames = [
 const uploadListSlotRecipeSlotFns = /* @__PURE__ */ uploadListSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, uploadListSlotRecipeDefaultVariants, getSlotCompoundVariant(uploadListSlotRecipeCompoundVariants, slotName))])
 
 const uploadListSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(uploadListSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(uploadListSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const uploadListSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...uploadListSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const uploadListSlotRecipe = /* @__PURE__ */ Object.assign(uploadListSlotRecipeFn, {
   __recipe__: false,
@@ -35,4 +36,5 @@ export const uploadListSlotRecipe = /* @__PURE__ */ Object.assign(uploadListSlot
   splitVariantProps(props) {
     return splitProps(props, uploadListSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

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

@@ -21,6 +21,7 @@ export interface UploadSlotRecipeRecipe {
   variantMap: UploadSlotRecipeVariantMap
   variantKeys: Array<keyof UploadSlotRecipeVariant>
   splitVariantProps<Props extends UploadSlotRecipeVariantProps>(props: Props): [UploadSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof UploadSlotRecipeVariantProps>>]
+  getVariantProps: (props?: UploadSlotRecipeVariantProps) => UploadSlotRecipeVariantProps
 }
 
 

package/recipes/upload-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 uploadSlotRecipeDefaultVariants = {}
@@ -17,10 +17,11 @@ const uploadSlotRecipeSlotNames = [
 const uploadSlotRecipeSlotFns = /* @__PURE__ */ uploadSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, uploadSlotRecipeDefaultVariants, getSlotCompoundVariant(uploadSlotRecipeCompoundVariants, slotName))])
 
 const uploadSlotRecipeFn = memo((props = {}) => {
-  return Object.fromEntries(uploadSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+  return Object.fromEntries(uploadSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
 })
 
 const uploadSlotRecipeVariantKeys = []
+const getVariantProps = (variants) => ({ ...uploadSlotRecipeDefaultVariants, ...compact(variants) })
 
 export const uploadSlotRecipe = /* @__PURE__ */ Object.assign(uploadSlotRecipeFn, {
   __recipe__: false,
@@ -31,4 +32,5 @@ export const uploadSlotRecipe = /* @__PURE__ */ Object.assign(uploadSlotRecipeFn
   splitVariantProps(props) {
     return splitProps(props, uploadSlotRecipeVariantKeys)
   },
+  getVariantProps
 })

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

@@ -21,6 +21,7 @@ export interface YearItemRecipeRecipe {
   variantMap: YearItemRecipeVariantMap
   variantKeys: Array<keyof YearItemRecipeVariant>
   splitVariantProps<Props extends YearItemRecipeVariantProps>(props: Props): [YearItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof YearItemRecipeVariantProps>>]
+  getVariantProps: (props?: YearItemRecipeVariantProps) => YearItemRecipeVariantProps
 }
 
 

package/recipes/year-item-recipe.mjs

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

package/tokens/tokens.d.ts

@@ -33,8 +33,6 @@ export type ZIndexToken = "hide" | "base" | "docked" | "sticky" | "overlay" | "m
 
 export type BreakpointToken = "sm" | "md" | "lg" | "xl"
 
-export type AnimationName = "fade-in" | "fade-out" | "spin"
-
 export type Tokens = {
 		borders: BorderToken
 		colors: ColorToken
@@ -51,7 +49,6 @@ export type Tokens = {
 		spacing: SpacingToken
 		zIndex: ZIndexToken
 		breakpoints: BreakpointToken
-		animationName: AnimationName
 } & { [token: string]: never }
 
 export type TokenCategory = "aspectRatios" | "zIndex" | "opacity" | "colors" | "fonts" | "fontSizes" | "fontWeights" | "lineHeights" | "letterSpacings" | "sizes" | "shadows" | "spacing" | "radii" | "borders" | "borderWidths" | "durations" | "easings" | "animations" | "blurs" | "gradients" | "breakpoints" | "assets"

package/types/composition.d.ts

@@ -15,34 +15,61 @@ interface Recursive<T> {
  * -----------------------------------------------------------------------------*/
 
 type TextStyleProperty =
+  | 'font'
+  | 'fontFamily'
+  | 'fontFeatureSettings'
+  | 'fontKerning'
+  | 'fontLanguageOverride'
+  | 'fontOpticalSizing'
+  | 'fontPalette'
   | 'fontSize'
   | 'fontSizeAdjust'
-  | 'fontVariationSettings'
-  | 'fontVariantPosition'
-  | 'fontVariantCaps'
-  | 'fontVariantNumeric'
+  | 'fontStretch'
+  | 'fontStyle'
+  | 'fontSynthesis'
+  | 'fontVariant'
   | 'fontVariantAlternates'
+  | 'fontVariantCaps'
   | 'fontVariantLigatures'
-  | 'fontFamily'
+  | 'fontVariantNumeric'
+  | 'fontVariantPosition'
+  | 'fontVariationSettings'
   | 'fontWeight'
-  | 'fontSynthesis'
-  | 'fontStyle'
-  | 'fontVariant'
-  | 'lineHeight'
+  | 'hypens'
+  | 'hyphenateCharacter'
+  | 'hyphenateLimitChars'
   | 'letterSpacing'
+  | 'lineBreak'
+  | 'lineHeight'
+  | 'quotes'
+  | 'overflowWrap'
+  | 'textCombineUpright'
   | 'textDecoration'
-  | 'textTransform'
-  | 'textIndent'
   | 'textDecorationColor'
   | 'textDecorationLine'
+  | 'textDecorationSkipInk'
   | 'textDecorationStyle'
+  | 'textDecorationThickness'
+  | 'textEmphasis'
   | 'textEmphasisColor'
   | 'textEmphasisPosition'
   | 'textEmphasisStyle'
-  | 'hyphenateCharacter'
+  | 'textIndent'
+  | 'textJustify'
   | 'textOrientation'
   | 'textOverflow'
   | 'textRendering'
+  | 'textShadow'
+  | 'textTransform'
+  | 'textUnderlineOffset'
+  | 'textUnderlinePosition'
+  | 'textWrap'
+  | 'textWrapMode'
+  | 'textWrapStyle'
+  | 'verticalAlign'
+  | 'whiteSpace'
+  | 'wordBreak'
+  | 'wordSpacing'
 
 export type TextStyle = CompositionStyleObject<TextStyleProperty>