@mekari/pixel3-styled-system 0.0.0

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputSlotRecipeVariant {
+  variant: "unstyled" | "outline"
+size: "sm" | "md"
+}
+
+type InputSlotRecipeVariantMap = {
+  [key in keyof InputSlotRecipeVariant]: Array<InputSlotRecipeVariant[key]>
+}
+
+export type InputSlotRecipeVariantProps = {
+  [key in keyof InputSlotRecipeVariant]?: ConditionalValue<InputSlotRecipeVariant[key]> | undefined
+}
+
+export interface InputSlotRecipeRecipe {
+  __type: InputSlotRecipeVariantProps
+  (props?: InputSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "clear", string>>
+  raw: (props?: InputSlotRecipeVariantProps) => InputSlotRecipeVariantProps
+  variantMap: InputSlotRecipeVariantMap
+  variantKeys: Array<keyof InputSlotRecipeVariant>
+  splitVariantProps<Props extends InputSlotRecipeVariantProps>(props: Props): [InputSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputSlotRecipeVariantProps>>]
+}
+
+
+export declare const inputSlotRecipe: InputSlotRecipeRecipe

package/recipes/input-slot-recipe.mjs

@@ -0,0 +1,53 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputSlotRecipeDefaultVariants = {
+  "size": "md",
+  "variant": "outline"
+}
+const inputSlotRecipeCompoundVariants = []
+
+const inputSlotRecipeSlotNames = [
+  [
+    "root",
+    "input__root"
+  ],
+  [
+    "control",
+    "input__control"
+  ],
+  [
+    "clear",
+    "input__clear"
+  ]
+]
+const inputSlotRecipeSlotFns = /* @__PURE__ */ inputSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputSlotRecipeDefaultVariants, getSlotCompoundVariant(inputSlotRecipeCompoundVariants, slotName))])
+
+const inputSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputSlotRecipeVariantKeys = [
+  "variant",
+  "size"
+]
+
+export const inputSlotRecipe = /* @__PURE__ */ Object.assign(inputSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputSlotRecipe',
+  raw: (props) => props,
+  variantKeys: inputSlotRecipeVariantKeys,
+  variantMap: {
+  "variant": [
+    "unstyled",
+    "outline"
+  ],
+  "size": [
+    "sm",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, inputSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PopoverContentRecipeVariant {
+  isUnstyled: boolean
+isDark: boolean
+}
+
+type PopoverContentRecipeVariantMap = {
+  [key in keyof PopoverContentRecipeVariant]: Array<PopoverContentRecipeVariant[key]>
+}
+
+export type PopoverContentRecipeVariantProps = {
+  [key in keyof PopoverContentRecipeVariant]?: ConditionalValue<PopoverContentRecipeVariant[key]> | undefined
+}
+
+export interface PopoverContentRecipeRecipe {
+  __type: PopoverContentRecipeVariantProps
+  (props?: PopoverContentRecipeVariantProps): string
+  raw: (props?: PopoverContentRecipeVariantProps) => PopoverContentRecipeVariantProps
+  variantMap: PopoverContentRecipeVariantMap
+  variantKeys: Array<keyof PopoverContentRecipeVariant>
+  splitVariantProps<Props extends PopoverContentRecipeVariantProps>(props: Props): [PopoverContentRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverContentRecipeVariantProps>>]
+}
+
+
+export declare const popoverContentRecipe: PopoverContentRecipeRecipe

package/recipes/popover-content-recipe.mjs

@@ -0,0 +1,34 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const popoverContentRecipeFn = /* @__PURE__ */ createRecipe('popover', {
+  "isDark": false,
+  "isUnstyled": false
+}, [])
+
+const popoverContentRecipeVariantMap = {
+  "isUnstyled": [
+    "true",
+    "false"
+  ],
+  "isDark": [
+    "true",
+    "false"
+  ]
+}
+
+const popoverContentRecipeVariantKeys = Object.keys(popoverContentRecipeVariantMap)
+
+export const popoverContentRecipe = /* @__PURE__ */ Object.assign(popoverContentRecipeFn, {
+  __recipe__: true,
+  __name__: 'popoverContentRecipe',
+  raw: (props) => props,
+  variantKeys: popoverContentRecipeVariantKeys,
+  variantMap: popoverContentRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, popoverContentRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PopoverListItemRecipeVariant {
+  
+}
+
+type PopoverListItemRecipeVariantMap = {
+  [key in keyof PopoverListItemRecipeVariant]: Array<PopoverListItemRecipeVariant[key]>
+}
+
+export type PopoverListItemRecipeVariantProps = {
+  [key in keyof PopoverListItemRecipeVariant]?: ConditionalValue<PopoverListItemRecipeVariant[key]> | undefined
+}
+
+export interface PopoverListItemRecipeRecipe {
+  __type: PopoverListItemRecipeVariantProps
+  (props?: PopoverListItemRecipeVariantProps): string
+  raw: (props?: PopoverListItemRecipeVariantProps) => PopoverListItemRecipeVariantProps
+  variantMap: PopoverListItemRecipeVariantMap
+  variantKeys: Array<keyof PopoverListItemRecipeVariant>
+  splitVariantProps<Props extends PopoverListItemRecipeVariantProps>(props: Props): [PopoverListItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverListItemRecipeVariantProps>>]
+}
+
+
+export declare const popoverListItemRecipe: PopoverListItemRecipeRecipe

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

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const popoverListItemRecipeFn = /* @__PURE__ */ createRecipe('popover-list-item', {}, [])
+
+const popoverListItemRecipeVariantMap = {}
+
+const popoverListItemRecipeVariantKeys = Object.keys(popoverListItemRecipeVariantMap)
+
+export const popoverListItemRecipe = /* @__PURE__ */ Object.assign(popoverListItemRecipeFn, {
+  __recipe__: true,
+  __name__: 'popoverListItemRecipe',
+  raw: (props) => props,
+  variantKeys: popoverListItemRecipeVariantKeys,
+  variantMap: popoverListItemRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, popoverListItemRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PopoverListRecipeVariant {
+  
+}
+
+type PopoverListRecipeVariantMap = {
+  [key in keyof PopoverListRecipeVariant]: Array<PopoverListRecipeVariant[key]>
+}
+
+export type PopoverListRecipeVariantProps = {
+  [key in keyof PopoverListRecipeVariant]?: ConditionalValue<PopoverListRecipeVariant[key]> | undefined
+}
+
+export interface PopoverListRecipeRecipe {
+  __type: PopoverListRecipeVariantProps
+  (props?: PopoverListRecipeVariantProps): string
+  raw: (props?: PopoverListRecipeVariantProps) => PopoverListRecipeVariantProps
+  variantMap: PopoverListRecipeVariantMap
+  variantKeys: Array<keyof PopoverListRecipeVariant>
+  splitVariantProps<Props extends PopoverListRecipeVariantProps>(props: Props): [PopoverListRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverListRecipeVariantProps>>]
+}
+
+
+export declare const popoverListRecipe: PopoverListRecipeRecipe

package/recipes/popover-list-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const popoverListRecipeFn = /* @__PURE__ */ createRecipe('popover-list', {}, [])
+
+const popoverListRecipeVariantMap = {}
+
+const popoverListRecipeVariantKeys = Object.keys(popoverListRecipeVariantMap)
+
+export const popoverListRecipe = /* @__PURE__ */ Object.assign(popoverListRecipeFn, {
+  __recipe__: true,
+  __name__: 'popoverListRecipe',
+  raw: (props) => props,
+  variantKeys: popoverListRecipeVariantKeys,
+  variantMap: popoverListRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, popoverListRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProgressSlotRecipeVariant {
+  size: "md" | "sm"
+variant: "linear" | "circular"
+}
+
+type ProgressSlotRecipeVariantMap = {
+  [key in keyof ProgressSlotRecipeVariant]: Array<ProgressSlotRecipeVariant[key]>
+}
+
+export type ProgressSlotRecipeVariantProps = {
+  [key in keyof ProgressSlotRecipeVariant]?: ConditionalValue<ProgressSlotRecipeVariant[key]> | undefined
+}
+
+export interface ProgressSlotRecipeRecipe {
+  __type: ProgressSlotRecipeVariantProps
+  (props?: ProgressSlotRecipeVariantProps): Pretty<Record<"root" | "linear" | "circularBase" | "circularTrack", string>>
+  raw: (props?: ProgressSlotRecipeVariantProps) => ProgressSlotRecipeVariantProps
+  variantMap: ProgressSlotRecipeVariantMap
+  variantKeys: Array<keyof ProgressSlotRecipeVariant>
+  splitVariantProps<Props extends ProgressSlotRecipeVariantProps>(props: Props): [ProgressSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressSlotRecipeVariantProps>>]
+}
+
+
+export declare const progressSlotRecipe: ProgressSlotRecipeRecipe

package/recipes/progress-slot-recipe.mjs

@@ -0,0 +1,57 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const progressSlotRecipeDefaultVariants = {
+  "variant": "linear",
+  "size": "md"
+}
+const progressSlotRecipeCompoundVariants = []
+
+const progressSlotRecipeSlotNames = [
+  [
+    "root",
+    "progress__root"
+  ],
+  [
+    "linear",
+    "progress__linear"
+  ],
+  [
+    "circularBase",
+    "progress__circularBase"
+  ],
+  [
+    "circularTrack",
+    "progress__circularTrack"
+  ]
+]
+const progressSlotRecipeSlotFns = /* @__PURE__ */ progressSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressSlotRecipeDefaultVariants, getSlotCompoundVariant(progressSlotRecipeCompoundVariants, slotName))])
+
+const progressSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(progressSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const progressSlotRecipeVariantKeys = [
+  "size",
+  "variant"
+]
+
+export const progressSlotRecipe = /* @__PURE__ */ Object.assign(progressSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'progressSlotRecipe',
+  raw: (props) => props,
+  variantKeys: progressSlotRecipeVariantKeys,
+  variantMap: {
+  "size": [
+    "md",
+    "sm"
+  ],
+  "variant": [
+    "linear",
+    "circular"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, progressSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioSlotRecipeVariant {
+  
+}
+
+type RadioSlotRecipeVariantMap = {
+  [key in keyof RadioSlotRecipeVariant]: Array<RadioSlotRecipeVariant[key]>
+}
+
+export type RadioSlotRecipeVariantProps = {
+  [key in keyof RadioSlotRecipeVariant]?: ConditionalValue<RadioSlotRecipeVariant[key]> | undefined
+}
+
+export interface RadioSlotRecipeRecipe {
+  __type: RadioSlotRecipeVariantProps
+  (props?: RadioSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "label", string>>
+  raw: (props?: RadioSlotRecipeVariantProps) => RadioSlotRecipeVariantProps
+  variantMap: RadioSlotRecipeVariantMap
+  variantKeys: Array<keyof RadioSlotRecipeVariant>
+  splitVariantProps<Props extends RadioSlotRecipeVariantProps>(props: Props): [RadioSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof RadioSlotRecipeVariantProps>>]
+}
+
+
+export declare const radioSlotRecipe: RadioSlotRecipeRecipe

package/recipes/radio-slot-recipe.mjs

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioSlotRecipeDefaultVariants = {}
+const radioSlotRecipeCompoundVariants = []
+
+const radioSlotRecipeSlotNames = [
+  [
+    "root",
+    "radio__root"
+  ],
+  [
+    "control",
+    "radio__control"
+  ],
+  [
+    "label",
+    "radio__label"
+  ]
+]
+const radioSlotRecipeSlotFns = /* @__PURE__ */ radioSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioSlotRecipeDefaultVariants, getSlotCompoundVariant(radioSlotRecipeCompoundVariants, slotName))])
+
+const radioSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(radioSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const radioSlotRecipeVariantKeys = []
+
+export const radioSlotRecipe = /* @__PURE__ */ Object.assign(radioSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'radioSlotRecipe',
+  raw: (props) => props,
+  variantKeys: radioSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, radioSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SelectSlotRecipeVariant {
+  size: "sm" | "md"
+}
+
+type SelectSlotRecipeVariantMap = {
+  [key in keyof SelectSlotRecipeVariant]: Array<SelectSlotRecipeVariant[key]>
+}
+
+export type SelectSlotRecipeVariantProps = {
+  [key in keyof SelectSlotRecipeVariant]?: ConditionalValue<SelectSlotRecipeVariant[key]> | undefined
+}
+
+export interface SelectSlotRecipeRecipe {
+  __type: SelectSlotRecipeVariantProps
+  (props?: SelectSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "clear" | "arrow", string>>
+  raw: (props?: SelectSlotRecipeVariantProps) => SelectSlotRecipeVariantProps
+  variantMap: SelectSlotRecipeVariantMap
+  variantKeys: Array<keyof SelectSlotRecipeVariant>
+  splitVariantProps<Props extends SelectSlotRecipeVariantProps>(props: Props): [SelectSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SelectSlotRecipeVariantProps>>]
+}
+
+
+export declare const selectSlotRecipe: SelectSlotRecipeRecipe

package/recipes/select-slot-recipe.mjs

@@ -0,0 +1,51 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const selectSlotRecipeDefaultVariants = {
+  "size": "md"
+}
+const selectSlotRecipeCompoundVariants = []
+
+const selectSlotRecipeSlotNames = [
+  [
+    "root",
+    "select__root"
+  ],
+  [
+    "control",
+    "select__control"
+  ],
+  [
+    "clear",
+    "select__clear"
+  ],
+  [
+    "arrow",
+    "select__arrow"
+  ]
+]
+const selectSlotRecipeSlotFns = /* @__PURE__ */ selectSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, selectSlotRecipeDefaultVariants, getSlotCompoundVariant(selectSlotRecipeCompoundVariants, slotName))])
+
+const selectSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(selectSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const selectSlotRecipeVariantKeys = [
+  "size"
+]
+
+export const selectSlotRecipe = /* @__PURE__ */ Object.assign(selectSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'selectSlotRecipe',
+  raw: (props) => props,
+  variantKeys: selectSlotRecipeVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, selectSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SelectedBorderRecipeVariant {
+  variantColor: "blue" | "green" | "orange" | "red" | "gray"
+isSelected: boolean
+}
+
+type SelectedBorderRecipeVariantMap = {
+  [key in keyof SelectedBorderRecipeVariant]: Array<SelectedBorderRecipeVariant[key]>
+}
+
+export type SelectedBorderRecipeVariantProps = {
+  [key in keyof SelectedBorderRecipeVariant]?: SelectedBorderRecipeVariant[key] | undefined
+}
+
+export interface SelectedBorderRecipeRecipe {
+  __type: SelectedBorderRecipeVariantProps
+  (props?: SelectedBorderRecipeVariantProps): string
+  raw: (props?: SelectedBorderRecipeVariantProps) => SelectedBorderRecipeVariantProps
+  variantMap: SelectedBorderRecipeVariantMap
+  variantKeys: Array<keyof SelectedBorderRecipeVariant>
+  splitVariantProps<Props extends SelectedBorderRecipeVariantProps>(props: Props): [SelectedBorderRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SelectedBorderRecipeVariantProps>>]
+}
+
+
+export declare const selectedBorderRecipe: SelectedBorderRecipeRecipe

package/recipes/selected-border-recipe.mjs

@@ -0,0 +1,88 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const selectedBorderRecipeFn = /* @__PURE__ */ createRecipe('selected-border', {
+  "variantColor": "blue",
+  "isSelected": false
+}, [
+  {
+    "variantColor": "blue",
+    "isSelected": true,
+    "css": {
+      "background": "blue.400",
+      "_groupHover": {
+        "background": "blue.500"
+      }
+    }
+  },
+  {
+    "variantColor": "green",
+    "isSelected": true,
+    "css": {
+      "background": "green.400",
+      "_groupHover": {
+        "background": "green.500"
+      }
+    }
+  },
+  {
+    "variantColor": "orange",
+    "isSelected": true,
+    "css": {
+      "background": "orange.400",
+      "_groupHover": {
+        "background": "orange.500"
+      }
+    }
+  },
+  {
+    "variantColor": "red",
+    "isSelected": true,
+    "css": {
+      "background": "red.400",
+      "_groupHover": {
+        "background": "red.500"
+      }
+    }
+  },
+  {
+    "variantColor": "gray",
+    "isSelected": true,
+    "css": {
+      "background": "gray.400",
+      "_groupHover": {
+        "background": "gray.500"
+      }
+    }
+  }
+])
+
+const selectedBorderRecipeVariantMap = {
+  "variantColor": [
+    "blue",
+    "green",
+    "orange",
+    "red",
+    "gray"
+  ],
+  "isSelected": [
+    "false",
+    "true"
+  ]
+}
+
+const selectedBorderRecipeVariantKeys = Object.keys(selectedBorderRecipeVariantMap)
+
+export const selectedBorderRecipe = /* @__PURE__ */ Object.assign(selectedBorderRecipeFn, {
+  __recipe__: true,
+  __name__: 'selectedBorderRecipe',
+  raw: (props) => props,
+  variantKeys: selectedBorderRecipeVariantKeys,
+  variantMap: selectedBorderRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, selectedBorderRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SharedSlotRecipeVariant {
+  
+}
+
+type SharedSlotRecipeVariantMap = {
+  [key in keyof SharedSlotRecipeVariant]: Array<SharedSlotRecipeVariant[key]>
+}
+
+export type SharedSlotRecipeVariantProps = {
+  [key in keyof SharedSlotRecipeVariant]?: ConditionalValue<SharedSlotRecipeVariant[key]> | undefined
+}
+
+export interface SharedSlotRecipeRecipe {
+  __type: SharedSlotRecipeVariantProps
+  (props?: SharedSlotRecipeVariantProps): Pretty<Record<"hidden", string>>
+  raw: (props?: SharedSlotRecipeVariantProps) => SharedSlotRecipeVariantProps
+  variantMap: SharedSlotRecipeVariantMap
+  variantKeys: Array<keyof SharedSlotRecipeVariant>
+  splitVariantProps<Props extends SharedSlotRecipeVariantProps>(props: Props): [SharedSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SharedSlotRecipeVariantProps>>]
+}
+
+
+export declare const sharedSlotRecipe: SharedSlotRecipeRecipe

package/recipes/shared-slot-recipe.mjs

@@ -0,0 +1,30 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const sharedSlotRecipeDefaultVariants = {}
+const sharedSlotRecipeCompoundVariants = []
+
+const sharedSlotRecipeSlotNames = [
+  [
+    "hidden",
+    "shared__hidden"
+  ]
+]
+const sharedSlotRecipeSlotFns = /* @__PURE__ */ sharedSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sharedSlotRecipeDefaultVariants, getSlotCompoundVariant(sharedSlotRecipeCompoundVariants, slotName))])
+
+const sharedSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(sharedSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const sharedSlotRecipeVariantKeys = []
+
+export const sharedSlotRecipe = /* @__PURE__ */ Object.assign(sharedSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'sharedSlotRecipe',
+  raw: (props) => props,
+  variantKeys: sharedSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, sharedSlotRecipeVariantKeys)
+  },
+})