@mekari/pixel3-styled-system 0.0.0

package/recipes/checkbox-slot-recipe.mjs

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const checkboxSlotRecipeDefaultVariants = {}
+const checkboxSlotRecipeCompoundVariants = []
+
+const checkboxSlotRecipeSlotNames = [
+  [
+    "root",
+    "checkbox__root"
+  ],
+  [
+    "control",
+    "checkbox__control"
+  ],
+  [
+    "label",
+    "checkbox__label"
+  ]
+]
+const checkboxSlotRecipeSlotFns = /* @__PURE__ */ checkboxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, checkboxSlotRecipeDefaultVariants, getSlotCompoundVariant(checkboxSlotRecipeCompoundVariants, slotName))])
+
+const checkboxSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(checkboxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const checkboxSlotRecipeVariantKeys = []
+
+export const checkboxSlotRecipe = /* @__PURE__ */ Object.assign(checkboxSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'checkboxSlotRecipe',
+  raw: (props) => props,
+  variantKeys: checkboxSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, checkboxSlotRecipeVariantKeys)
+  },
+})

package/recipes/create-recipe.d.ts

@@ -0,0 +1 @@
+/* eslint-disable */

package/recipes/create-recipe.mjs

@@ -0,0 +1,79 @@
+import { finalizeConditions, sortConditions } from '../css/conditions.mjs';
+import { css } from '../css/css.mjs';
+import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.mjs';
+import { cx } from '../css/cx.mjs';
+import { compact, createCss, splitProps, uniq, withoutSpace } from '../helpers.mjs';
+
+export const createRecipe = (name, defaultVariants, compoundVariants) => {
+ const getRecipeStyles = (variants) => {
+   return {
+     [name]: '__ignore__',
+     ...defaultVariants,
+     ...compact(variants),
+   };
+ };
+
+  const recipeFn = (variants, withCompoundVariants = true) => {
+   const transform = (prop, value) => {
+     assertCompoundVariant(name, compoundVariants, variants, prop)
+
+      if (value === '__ignore__') {
+        return { className: name }
+      }
+
+      value = withoutSpace(value)
+      return { className: `${name}--${prop}_${value}` }
+   }
+
+   const recipeCss = createCss({
+     
+     conditions: {
+       shift: sortConditions,
+       finalize: finalizeConditions,
+       breakpoints: { keys: ["base","sm","md","lg","xl"] }
+     },
+     utility: {
+       prefix: "mp",
+       transform,
+     }
+   })
+
+   const recipeStyles = getRecipeStyles(variants)
+
+   if (withCompoundVariants) {
+     const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles)
+     return cx(recipeCss(recipeStyles), css(compoundVariantStyles))
+   }
+
+   return recipeCss(recipeStyles)
+  }
+
+   return Object.assign(recipeFn, {
+     __getCompoundVariantCss__: (variants) => {
+       return getCompoundVariantCss(compoundVariants, getRecipeStyles(variants));
+     },
+   })
+}
+
+export const mergeRecipes = (recipeA, recipeB) => {
+ if (recipeA && !recipeB) return recipeA
+ if (!recipeA && recipeB) return recipeB
+
+ const recipeFn = (...args) => cx(recipeA(...args), recipeB(...args))
+ const variantKeys = uniq(recipeA.variantKeys, recipeB.variantKeys)
+ const variantMap = variantKeys.reduce((acc, key) => {
+   acc[key] = uniq(recipeA.variantMap[key], recipeB.variantMap[key])
+   return acc
+ }, {})
+
+ return Object.assign(recipeFn, {
+   __recipe__: true,
+   __name__: `${recipeA.__name__} ${recipeB.__name__}`,
+   raw: (props) => props,
+   variantKeys,
+   variantMap,
+   splitVariantProps(props) {
+     return splitProps(props, variantKeys)
+   },
+ })
+ }

package/recipes/icon-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface IconRecipeVariant {
+  size: "sm" | "md"
+}
+
+type IconRecipeVariantMap = {
+  [key in keyof IconRecipeVariant]: Array<IconRecipeVariant[key]>
+}
+
+export type IconRecipeVariantProps = {
+  [key in keyof IconRecipeVariant]?: ConditionalValue<IconRecipeVariant[key]> | undefined
+}
+
+export interface IconRecipeRecipe {
+  __type: IconRecipeVariantProps
+  (props?: IconRecipeVariantProps): string
+  raw: (props?: IconRecipeVariantProps) => IconRecipeVariantProps
+  variantMap: IconRecipeVariantMap
+  variantKeys: Array<keyof IconRecipeVariant>
+  splitVariantProps<Props extends IconRecipeVariantProps>(props: Props): [IconRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof IconRecipeVariantProps>>]
+}
+
+
+export declare const iconRecipe: IconRecipeRecipe

package/recipes/icon-recipe.mjs

@@ -0,0 +1,29 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const iconRecipeFn = /* @__PURE__ */ createRecipe('icon', {
+  "size": "md"
+}, [])
+
+const iconRecipeVariantMap = {
+  "size": [
+    "sm",
+    "md"
+  ]
+}
+
+const iconRecipeVariantKeys = Object.keys(iconRecipeVariantMap)
+
+export const iconRecipe = /* @__PURE__ */ Object.assign(iconRecipeFn, {
+  __recipe__: true,
+  __name__: 'iconRecipe',
+  raw: (props) => props,
+  variantKeys: iconRecipeVariantKeys,
+  variantMap: iconRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, iconRecipeVariantKeys)
+  },
+})

package/recipes/index.d.ts

@@ -0,0 +1,30 @@
+/* eslint-disable */
+export * from './button-recipe';
+export * from './button-group-recipe';
+export * from './text-recipe';
+export * from './icon-recipe';
+export * from './spinner-recipe';
+export * from './popover-content-recipe';
+export * from './popover-list-recipe';
+export * from './popover-list-item-recipe';
+export * from './badge-recipe';
+export * from './textarea-recipe';
+export * from './tooltip-recipe';
+export * from './tab-list-recipe';
+export * from './tab-recipe';
+export * from './selected-border-recipe';
+export * from './table-recipe';
+export * from './table-container-recipe';
+export * from './accordion';
+export * from './checkbox-slot-recipe';
+export * from './radio-slot-recipe';
+export * from './shared-slot-recipe';
+export * from './progress-slot-recipe';
+export * from './toggle-slot-recipe';
+export * from './tag-slot-recipe';
+export * from './input-slot-recipe';
+export * from './input-group-slot-recipe';
+export * from './input-addon-slot-recipe';
+export * from './avatar-slot-recipe';
+export * from './avatar-group-slot-recipe';
+export * from './select-slot-recipe';

package/recipes/index.mjs

@@ -0,0 +1,29 @@
+export * from './button-recipe.mjs';
+export * from './button-group-recipe.mjs';
+export * from './text-recipe.mjs';
+export * from './icon-recipe.mjs';
+export * from './spinner-recipe.mjs';
+export * from './popover-content-recipe.mjs';
+export * from './popover-list-recipe.mjs';
+export * from './popover-list-item-recipe.mjs';
+export * from './badge-recipe.mjs';
+export * from './textarea-recipe.mjs';
+export * from './tooltip-recipe.mjs';
+export * from './tab-list-recipe.mjs';
+export * from './tab-recipe.mjs';
+export * from './selected-border-recipe.mjs';
+export * from './table-recipe.mjs';
+export * from './table-container-recipe.mjs';
+export * from './accordion.mjs';
+export * from './checkbox-slot-recipe.mjs';
+export * from './radio-slot-recipe.mjs';
+export * from './shared-slot-recipe.mjs';
+export * from './progress-slot-recipe.mjs';
+export * from './toggle-slot-recipe.mjs';
+export * from './tag-slot-recipe.mjs';
+export * from './input-slot-recipe.mjs';
+export * from './input-group-slot-recipe.mjs';
+export * from './input-addon-slot-recipe.mjs';
+export * from './avatar-slot-recipe.mjs';
+export * from './avatar-group-slot-recipe.mjs';
+export * from './select-slot-recipe.mjs';

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

@@ -0,0 +1,29 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputAddonRecipeVariant {
+  placement: "left" | "right"
+  size: "sm" | "md"
+  "has-background": boolean
+}
+
+type InputAddonRecipeVariantMap = {
+  [key in keyof InputAddonRecipeVariant]: Array<InputAddonRecipeVariant[key]>
+}
+
+export type InputAddonRecipeVariantProps = {
+  [key in keyof InputAddonRecipeVariant]?: InputAddonRecipeVariant[key]
+}
+
+export interface InputAddonRecipeRecipe {
+  __type: InputAddonRecipeVariantProps
+  (props?: InputAddonRecipeVariantProps): Pretty<Record<"root", string>>
+  raw: (props?: InputAddonRecipeVariantProps) => InputAddonRecipeVariantProps
+  variantMap: InputAddonRecipeVariantMap
+  variantKeys: Array<keyof InputAddonRecipeVariant>
+  splitVariantProps<Props extends InputAddonRecipeVariantProps>(props: Props): [InputAddonRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputAddonRecipeVariantProps>>]
+}
+
+
+export declare const inputAddonRecipe: InputAddonRecipeRecipe

package/recipes/input-addon-recipe.mjs

@@ -0,0 +1,107 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputAddonRecipeDefaultVariants = {
+  "size": "md",
+  "placement": "left",
+  "has-background": false
+}
+const inputAddonRecipeCompoundVariants = [
+  {
+    "placement": "left",
+    "has-background": true,
+    "size": "sm",
+    "css": {
+      "root": {
+        "left": "0.5"
+      }
+    }
+  },
+  {
+    "placement": "right",
+    "has-background": true,
+    "size": "sm",
+    "css": {
+      "root": {
+        "right": "0.5"
+      }
+    }
+  },
+  {
+    "placement": "left",
+    "has-background": true,
+    "size": "md",
+    "css": {
+      "root": {
+        "left": "1"
+      }
+    }
+  },
+  {
+    "placement": "right",
+    "has-background": true,
+    "size": "md",
+    "css": {
+      "root": {
+        "right": "1"
+      }
+    }
+  },
+  {
+    "has-background": true,
+    "css": {
+      "root": {
+        "backgroundColor": "gray.50"
+      }
+    }
+  },
+  {
+    "has-background": false,
+    "css": {
+      "root": {
+        "backgroundColor": "transparent"
+      }
+    }
+  }
+]
+
+const inputAddonRecipeSlotNames = [
+  [
+    "root",
+    "input-addon__root"
+  ]
+]
+const inputAddonRecipeSlotFns = /* @__PURE__ */ inputAddonRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputAddonRecipeDefaultVariants, getSlotCompoundVariant(inputAddonRecipeCompoundVariants, slotName))])
+
+const inputAddonRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputAddonRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputAddonRecipeVariantKeys = [
+  "placement",
+  "size",
+  "has-background"
+]
+
+export const inputAddonRecipe = /* @__PURE__ */ Object.assign(inputAddonRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputAddonRecipe',
+  raw: (props) => props,
+  variantKeys: inputAddonRecipeVariantKeys,
+  variantMap: {
+  "placement": [
+    "left",
+    "right"
+  ],
+  "size": [
+    "sm",
+    "md"
+  ],
+  "has-background": [
+    "true"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, inputAddonRecipeVariantKeys)
+  },
+})

package/recipes/input-addon-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 InputAddonSlotRecipeVariant {
+  placement: "left" | "right"
+size: "sm" | "md"
+}
+
+type InputAddonSlotRecipeVariantMap = {
+  [key in keyof InputAddonSlotRecipeVariant]: Array<InputAddonSlotRecipeVariant[key]>
+}
+
+export type InputAddonSlotRecipeVariantProps = {
+  [key in keyof InputAddonSlotRecipeVariant]?: ConditionalValue<InputAddonSlotRecipeVariant[key]> | undefined
+}
+
+export interface InputAddonSlotRecipeRecipe {
+  __type: InputAddonSlotRecipeVariantProps
+  (props?: InputAddonSlotRecipeVariantProps): Pretty<Record<"root", string>>
+  raw: (props?: InputAddonSlotRecipeVariantProps) => InputAddonSlotRecipeVariantProps
+  variantMap: InputAddonSlotRecipeVariantMap
+  variantKeys: Array<keyof InputAddonSlotRecipeVariant>
+  splitVariantProps<Props extends InputAddonSlotRecipeVariantProps>(props: Props): [InputAddonSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputAddonSlotRecipeVariantProps>>]
+}
+
+
+export declare const inputAddonSlotRecipe: InputAddonSlotRecipeRecipe

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

@@ -0,0 +1,45 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputAddonSlotRecipeDefaultVariants = {
+  "size": "md",
+  "placement": "left"
+}
+const inputAddonSlotRecipeCompoundVariants = []
+
+const inputAddonSlotRecipeSlotNames = [
+  [
+    "root",
+    "input-addon__root"
+  ]
+]
+const inputAddonSlotRecipeSlotFns = /* @__PURE__ */ inputAddonSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputAddonSlotRecipeDefaultVariants, getSlotCompoundVariant(inputAddonSlotRecipeCompoundVariants, slotName))])
+
+const inputAddonSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputAddonSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputAddonSlotRecipeVariantKeys = [
+  "placement",
+  "size"
+]
+
+export const inputAddonSlotRecipe = /* @__PURE__ */ Object.assign(inputAddonSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputAddonSlotRecipe',
+  raw: (props) => props,
+  variantKeys: inputAddonSlotRecipeVariantKeys,
+  variantMap: {
+  "placement": [
+    "left",
+    "right"
+  ],
+  "size": [
+    "sm",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, inputAddonSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputGroupRecipeVariant {
+  
+}
+
+type InputGroupRecipeVariantMap = {
+  [key in keyof InputGroupRecipeVariant]: Array<InputGroupRecipeVariant[key]>
+}
+
+export type InputGroupRecipeVariantProps = {
+  [key in keyof InputGroupRecipeVariant]?: ConditionalValue<InputGroupRecipeVariant[key]>
+}
+
+export interface InputGroupRecipeRecipe {
+  __type: InputGroupRecipeVariantProps
+  (props?: InputGroupRecipeVariantProps): Pretty<Record<"root", string>>
+  raw: (props?: InputGroupRecipeVariantProps) => InputGroupRecipeVariantProps
+  variantMap: InputGroupRecipeVariantMap
+  variantKeys: Array<keyof InputGroupRecipeVariant>
+  splitVariantProps<Props extends InputGroupRecipeVariantProps>(props: Props): [InputGroupRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputGroupRecipeVariantProps>>]
+}
+
+
+export declare const inputGroupRecipe: InputGroupRecipeRecipe

package/recipes/input-group-recipe.mjs

@@ -0,0 +1,30 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputGroupRecipeDefaultVariants = {}
+const inputGroupRecipeCompoundVariants = []
+
+const inputGroupRecipeSlotNames = [
+  [
+    "root",
+    "input-group__root"
+  ]
+]
+const inputGroupRecipeSlotFns = /* @__PURE__ */ inputGroupRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputGroupRecipeDefaultVariants, getSlotCompoundVariant(inputGroupRecipeCompoundVariants, slotName))])
+
+const inputGroupRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputGroupRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputGroupRecipeVariantKeys = []
+
+export const inputGroupRecipe = /* @__PURE__ */ Object.assign(inputGroupRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputGroupRecipe',
+  raw: (props) => props,
+  variantKeys: inputGroupRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, inputGroupRecipeVariantKeys)
+  },
+})

package/recipes/input-group-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 InputGroupSlotRecipeVariant {
+  
+}
+
+type InputGroupSlotRecipeVariantMap = {
+  [key in keyof InputGroupSlotRecipeVariant]: Array<InputGroupSlotRecipeVariant[key]>
+}
+
+export type InputGroupSlotRecipeVariantProps = {
+  [key in keyof InputGroupSlotRecipeVariant]?: ConditionalValue<InputGroupSlotRecipeVariant[key]> | undefined
+}
+
+export interface InputGroupSlotRecipeRecipe {
+  __type: InputGroupSlotRecipeVariantProps
+  (props?: InputGroupSlotRecipeVariantProps): Pretty<Record<"root", string>>
+  raw: (props?: InputGroupSlotRecipeVariantProps) => InputGroupSlotRecipeVariantProps
+  variantMap: InputGroupSlotRecipeVariantMap
+  variantKeys: Array<keyof InputGroupSlotRecipeVariant>
+  splitVariantProps<Props extends InputGroupSlotRecipeVariantProps>(props: Props): [InputGroupSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputGroupSlotRecipeVariantProps>>]
+}
+
+
+export declare const inputGroupSlotRecipe: InputGroupSlotRecipeRecipe

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

@@ -0,0 +1,30 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputGroupSlotRecipeDefaultVariants = {}
+const inputGroupSlotRecipeCompoundVariants = []
+
+const inputGroupSlotRecipeSlotNames = [
+  [
+    "root",
+    "input-group__root"
+  ]
+]
+const inputGroupSlotRecipeSlotFns = /* @__PURE__ */ inputGroupSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputGroupSlotRecipeDefaultVariants, getSlotCompoundVariant(inputGroupSlotRecipeCompoundVariants, slotName))])
+
+const inputGroupSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputGroupSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputGroupSlotRecipeVariantKeys = []
+
+export const inputGroupSlotRecipe = /* @__PURE__ */ Object.assign(inputGroupSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputGroupSlotRecipe',
+  raw: (props) => props,
+  variantKeys: inputGroupSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, inputGroupSlotRecipeVariantKeys)
+  },
+})

package/recipes/input-recipe.d.ts

@@ -0,0 +1,30 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputRecipeVariant {
+  variant: "unstyled" | "outline"
+  size: "sm" | "md"
+  "is-invalid": boolean
+  "is-full-width": boolean
+}
+
+type InputRecipeVariantMap = {
+  [key in keyof InputRecipeVariant]: Array<InputRecipeVariant[key]>
+}
+
+export type InputRecipeVariantProps = {
+  [key in keyof InputRecipeVariant]?: ConditionalValue<InputRecipeVariant[key]>
+}
+
+export interface InputRecipeRecipe {
+  __type: InputRecipeVariantProps
+  (props?: InputRecipeVariantProps): Pretty<Record<"root" | "control" | "clear", string>>
+  raw: (props?: InputRecipeVariantProps) => InputRecipeVariantProps
+  variantMap: InputRecipeVariantMap
+  variantKeys: Array<keyof InputRecipeVariant>
+  splitVariantProps<Props extends InputRecipeVariantProps>(props: Props): [InputRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputRecipeVariantProps>>]
+}
+
+
+export declare const inputRecipe: InputRecipeRecipe

package/recipes/input-recipe.mjs

@@ -0,0 +1,63 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputRecipeDefaultVariants = {
+  "size": "md",
+  "variant": "outline",
+  "is-invalid": false,
+  "is-full-width": true
+}
+const inputRecipeCompoundVariants = []
+
+const inputRecipeSlotNames = [
+  [
+    "root",
+    "input__root"
+  ],
+  [
+    "control",
+    "input__control"
+  ],
+  [
+    "clear",
+    "input__clear"
+  ]
+]
+const inputRecipeSlotFns = /* @__PURE__ */ inputRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputRecipeDefaultVariants, getSlotCompoundVariant(inputRecipeCompoundVariants, slotName))])
+
+const inputRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputRecipeVariantKeys = [
+  "variant",
+  "size",
+  "is-invalid",
+  "is-full-width"
+]
+
+export const inputRecipe = /* @__PURE__ */ Object.assign(inputRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputRecipe',
+  raw: (props) => props,
+  variantKeys: inputRecipeVariantKeys,
+  variantMap: {
+  "variant": [
+    "unstyled",
+    "outline"
+  ],
+  "size": [
+    "sm",
+    "md"
+  ],
+  "is-invalid": [
+    "true"
+  ],
+  "is-full-width": [
+    "true"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, inputRecipeVariantKeys)
+  },
+})