@mekari/pixel3-styled-system 0.0.1-alpha.0 → 0.0.2

package/recipes/banner-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BannerRecipeVariant {
+  variant: "info" | "success" | "danger" | "warning"
+}
+
+type BannerRecipeVariantMap = {
+  [key in keyof BannerRecipeVariant]: Array<BannerRecipeVariant[key]>
+}
+
+export type BannerRecipeVariantProps = {
+  [key in keyof BannerRecipeVariant]?: ConditionalValue<BannerRecipeVariant[key]> | undefined
+}
+
+export interface BannerRecipeRecipe {
+  __type: BannerRecipeVariantProps
+  (props?: BannerRecipeVariantProps): string
+  raw: (props?: BannerRecipeVariantProps) => BannerRecipeVariantProps
+  variantMap: BannerRecipeVariantMap
+  variantKeys: Array<keyof BannerRecipeVariant>
+  splitVariantProps<Props extends BannerRecipeVariantProps>(props: Props): [BannerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BannerRecipeVariantProps>>]
+}
+
+
+export declare const bannerRecipe: BannerRecipeRecipe

package/recipes/banner-recipe.mjs

@@ -0,0 +1,31 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const bannerRecipeFn = /* @__PURE__ */ createRecipe('banner', {
+  "variant": "info"
+}, [])
+
+const bannerRecipeVariantMap = {
+  "variant": [
+    "info",
+    "success",
+    "danger",
+    "warning"
+  ]
+}
+
+const bannerRecipeVariantKeys = Object.keys(bannerRecipeVariantMap)
+
+export const bannerRecipe = /* @__PURE__ */ Object.assign(bannerRecipeFn, {
+  __recipe__: true,
+  __name__: 'bannerRecipe',
+  raw: (props) => props,
+  variantKeys: bannerRecipeVariantKeys,
+  variantMap: bannerRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, bannerRecipeVariantKeys)
+  },
+})

package/recipes/banner-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 BannerSlotRecipeVariant {
+  variant: "info" | "success" | "danger" | "warning"
+}
+
+type BannerSlotRecipeVariantMap = {
+  [key in keyof BannerSlotRecipeVariant]: Array<BannerSlotRecipeVariant[key]>
+}
+
+export type BannerSlotRecipeVariantProps = {
+  [key in keyof BannerSlotRecipeVariant]?: ConditionalValue<BannerSlotRecipeVariant[key]> | undefined
+}
+
+export interface BannerSlotRecipeRecipe {
+  __type: BannerSlotRecipeVariantProps
+  (props?: BannerSlotRecipeVariantProps): Pretty<Record<"root" | "body", string>>
+  raw: (props?: BannerSlotRecipeVariantProps) => BannerSlotRecipeVariantProps
+  variantMap: BannerSlotRecipeVariantMap
+  variantKeys: Array<keyof BannerSlotRecipeVariant>
+  splitVariantProps<Props extends BannerSlotRecipeVariantProps>(props: Props): [BannerSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BannerSlotRecipeVariantProps>>]
+}
+
+
+export declare const bannerSlotRecipe: BannerSlotRecipeRecipe

package/recipes/banner-slot-recipe.mjs

@@ -0,0 +1,45 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const bannerSlotRecipeDefaultVariants = {
+  "variant": "info"
+}
+const bannerSlotRecipeCompoundVariants = []
+
+const bannerSlotRecipeSlotNames = [
+  [
+    "root",
+    "banner__root"
+  ],
+  [
+    "body",
+    "banner__body"
+  ]
+]
+const bannerSlotRecipeSlotFns = /* @__PURE__ */ bannerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, bannerSlotRecipeDefaultVariants, getSlotCompoundVariant(bannerSlotRecipeCompoundVariants, slotName))])
+
+const bannerSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(bannerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const bannerSlotRecipeVariantKeys = [
+  "variant"
+]
+
+export const bannerSlotRecipe = /* @__PURE__ */ Object.assign(bannerSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'bannerSlotRecipe',
+  raw: (props) => props,
+  variantKeys: bannerSlotRecipeVariantKeys,
+  variantMap: {
+  "variant": [
+    "info",
+    "success",
+    "danger",
+    "warning"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, bannerSlotRecipeVariantKeys)
+  },
+})

package/recipes/banner-title-recipe.d.ts

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

package/recipes/banner-title-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const bannerTitleRecipeFn = /* @__PURE__ */ createRecipe('banner-title', {}, [])
+
+const bannerTitleRecipeVariantMap = {}
+
+const bannerTitleRecipeVariantKeys = Object.keys(bannerTitleRecipeVariantMap)
+
+export const bannerTitleRecipe = /* @__PURE__ */ Object.assign(bannerTitleRecipeFn, {
+  __recipe__: true,
+  __name__: 'bannerTitleRecipe',
+  raw: (props) => props,
+  variantKeys: bannerTitleRecipeVariantKeys,
+  variantMap: bannerTitleRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, bannerTitleRecipeVariantKeys)
+  },
+})

package/recipes/divider-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DividerRecipeVariant {
+  orientation: "horizontal" | "vertical"
+}
+
+type DividerRecipeVariantMap = {
+  [key in keyof DividerRecipeVariant]: Array<DividerRecipeVariant[key]>
+}
+
+export type DividerRecipeVariantProps = {
+  [key in keyof DividerRecipeVariant]?: ConditionalValue<DividerRecipeVariant[key]> | undefined
+}
+
+export interface DividerRecipeRecipe {
+  __type: DividerRecipeVariantProps
+  (props?: DividerRecipeVariantProps): string
+  raw: (props?: DividerRecipeVariantProps) => DividerRecipeVariantProps
+  variantMap: DividerRecipeVariantMap
+  variantKeys: Array<keyof DividerRecipeVariant>
+  splitVariantProps<Props extends DividerRecipeVariantProps>(props: Props): [DividerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DividerRecipeVariantProps>>]
+}
+
+
+export declare const dividerRecipe: DividerRecipeRecipe

package/recipes/divider-recipe.mjs

@@ -0,0 +1,29 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const dividerRecipeFn = /* @__PURE__ */ createRecipe('divider', {
+  "orientation": "horizontal"
+}, [])
+
+const dividerRecipeVariantMap = {
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ]
+}
+
+const dividerRecipeVariantKeys = Object.keys(dividerRecipeVariantMap)
+
+export const dividerRecipe = /* @__PURE__ */ Object.assign(dividerRecipeFn, {
+  __recipe__: true,
+  __name__: 'dividerRecipe',
+  raw: (props) => props,
+  variantKeys: dividerRecipeVariantKeys,
+  variantMap: dividerRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, dividerRecipeVariantKeys)
+  },
+})

package/recipes/dropzone-recipe.d.ts

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

package/recipes/dropzone-recipe.mjs

@@ -0,0 +1,34 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dropzoneRecipeDefaultVariants = {}
+const dropzoneRecipeCompoundVariants = []
+
+const dropzoneRecipeSlotNames = [
+  [
+    "root",
+    "dropzone__root"
+  ],
+  [
+    "wrapper",
+    "dropzone__wrapper"
+  ]
+]
+const dropzoneRecipeSlotFns = /* @__PURE__ */ dropzoneRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropzoneRecipeDefaultVariants, getSlotCompoundVariant(dropzoneRecipeCompoundVariants, slotName))])
+
+const dropzoneRecipeFn = (props = {}) => {
+  return Object.fromEntries(dropzoneRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dropzoneRecipeVariantKeys = []
+
+export const dropzoneRecipe = /* @__PURE__ */ Object.assign(dropzoneRecipeFn, {
+  __recipe__: false,
+  __name__: 'dropzoneRecipe',
+  raw: (props) => props,
+  variantKeys: dropzoneRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dropzoneRecipeVariantKeys)
+  },
+})

package/recipes/dropzone-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 DropzoneSlotRecipeVariant {
+  
+}
+
+type DropzoneSlotRecipeVariantMap = {
+  [key in keyof DropzoneSlotRecipeVariant]: Array<DropzoneSlotRecipeVariant[key]>
+}
+
+export type DropzoneSlotRecipeVariantProps = {
+  [key in keyof DropzoneSlotRecipeVariant]?: ConditionalValue<DropzoneSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropzoneSlotRecipeRecipe {
+  __type: DropzoneSlotRecipeVariantProps
+  (props?: DropzoneSlotRecipeVariantProps): Pretty<Record<"root" | "wrapper" | "box" | "logoBox" | "productBox" | "avatarBox" | "overlayWrapper" | "overlay" | "preview" | "overlayPreview" | "clearButton", string>>
+  raw: (props?: DropzoneSlotRecipeVariantProps) => DropzoneSlotRecipeVariantProps
+  variantMap: DropzoneSlotRecipeVariantMap
+  variantKeys: Array<keyof DropzoneSlotRecipeVariant>
+  splitVariantProps<Props extends DropzoneSlotRecipeVariantProps>(props: Props): [DropzoneSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropzoneSlotRecipeVariantProps>>]
+}
+
+
+export declare const dropzoneSlotRecipe: DropzoneSlotRecipeRecipe

package/recipes/dropzone-slot-recipe.mjs

@@ -0,0 +1,70 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dropzoneSlotRecipeDefaultVariants = {}
+const dropzoneSlotRecipeCompoundVariants = []
+
+const dropzoneSlotRecipeSlotNames = [
+  [
+    "root",
+    "dropzone__root"
+  ],
+  [
+    "wrapper",
+    "dropzone__wrapper"
+  ],
+  [
+    "box",
+    "dropzone__box"
+  ],
+  [
+    "logoBox",
+    "dropzone__logoBox"
+  ],
+  [
+    "productBox",
+    "dropzone__productBox"
+  ],
+  [
+    "avatarBox",
+    "dropzone__avatarBox"
+  ],
+  [
+    "overlayWrapper",
+    "dropzone__overlayWrapper"
+  ],
+  [
+    "overlay",
+    "dropzone__overlay"
+  ],
+  [
+    "preview",
+    "dropzone__preview"
+  ],
+  [
+    "overlayPreview",
+    "dropzone__overlayPreview"
+  ],
+  [
+    "clearButton",
+    "dropzone__clearButton"
+  ]
+]
+const dropzoneSlotRecipeSlotFns = /* @__PURE__ */ dropzoneSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropzoneSlotRecipeDefaultVariants, getSlotCompoundVariant(dropzoneSlotRecipeCompoundVariants, slotName))])
+
+const dropzoneSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(dropzoneSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dropzoneSlotRecipeVariantKeys = []
+
+export const dropzoneSlotRecipe = /* @__PURE__ */ Object.assign(dropzoneSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'dropzoneSlotRecipe',
+  raw: (props) => props,
+  variantKeys: dropzoneSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dropzoneSlotRecipeVariantKeys)
+  },
+})

package/recipes/form-control-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 FormControlSlotRecipeVariant {
+  
+}
+
+type FormControlSlotRecipeVariantMap = {
+  [key in keyof FormControlSlotRecipeVariant]: Array<FormControlSlotRecipeVariant[key]>
+}
+
+export type FormControlSlotRecipeVariantProps = {
+  [key in keyof FormControlSlotRecipeVariant]?: ConditionalValue<FormControlSlotRecipeVariant[key]> | undefined
+}
+
+export interface FormControlSlotRecipeRecipe {
+  __type: FormControlSlotRecipeVariantProps
+  (props?: FormControlSlotRecipeVariantProps): Pretty<Record<"root" | "label" | "required" | "helpText" | "errorMessage", string>>
+  raw: (props?: FormControlSlotRecipeVariantProps) => FormControlSlotRecipeVariantProps
+  variantMap: FormControlSlotRecipeVariantMap
+  variantKeys: Array<keyof FormControlSlotRecipeVariant>
+  splitVariantProps<Props extends FormControlSlotRecipeVariantProps>(props: Props): [FormControlSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof FormControlSlotRecipeVariantProps>>]
+}
+
+
+export declare const formControlSlotRecipe: FormControlSlotRecipeRecipe

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

@@ -0,0 +1,46 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const formControlSlotRecipeDefaultVariants = {}
+const formControlSlotRecipeCompoundVariants = []
+
+const formControlSlotRecipeSlotNames = [
+  [
+    "root",
+    "form-control__root"
+  ],
+  [
+    "label",
+    "form-control__label"
+  ],
+  [
+    "required",
+    "form-control__required"
+  ],
+  [
+    "helpText",
+    "form-control__helpText"
+  ],
+  [
+    "errorMessage",
+    "form-control__errorMessage"
+  ]
+]
+const formControlSlotRecipeSlotFns = /* @__PURE__ */ formControlSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, formControlSlotRecipeDefaultVariants, getSlotCompoundVariant(formControlSlotRecipeCompoundVariants, slotName))])
+
+const formControlSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(formControlSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const formControlSlotRecipeVariantKeys = []
+
+export const formControlSlotRecipe = /* @__PURE__ */ Object.assign(formControlSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'formControlSlotRecipe',
+  raw: (props) => props,
+  variantKeys: formControlSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, formControlSlotRecipeVariantKeys)
+  },
+})

package/recipes/index.d.ts

@@ -15,6 +15,11 @@ export * from './tab-recipe';
 export * from './selected-border-recipe';
 export * from './table-recipe';
 export * from './table-container-recipe';
+export * from './divider-recipe';
+export * from './banner-title-recipe';
+export * from './banner-description-recipe';
+export * from './banner-link-recipe';
+export * from './banner-close-button-recipe';
 export * from './accordion';
 export * from './checkbox-slot-recipe';
 export * from './radio-slot-recipe';
@@ -27,4 +32,12 @@ 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';
+export * from './select-slot-recipe';
+export * from './form-control-slot-recipe';
+export * from './input-tag-slot-recipe';
+export * from './modal-slot-recipe';
+export * from './upload-slot-recipe';
+export * from './upload-list-slot-recipe';
+export * from './dropzone-slot-recipe';
+export * from './banner-slot-recipe';
+export * from './banner-icon-slot-recipe';

package/recipes/index.mjs

@@ -14,6 +14,11 @@ export * from './tab-recipe.mjs';
 export * from './selected-border-recipe.mjs';
 export * from './table-recipe.mjs';
 export * from './table-container-recipe.mjs';
+export * from './divider-recipe.mjs';
+export * from './banner-title-recipe.mjs';
+export * from './banner-description-recipe.mjs';
+export * from './banner-link-recipe.mjs';
+export * from './banner-close-button-recipe.mjs';
 export * from './accordion.mjs';
 export * from './checkbox-slot-recipe.mjs';
 export * from './radio-slot-recipe.mjs';
@@ -26,4 +31,12 @@ 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';
+export * from './select-slot-recipe.mjs';
+export * from './form-control-slot-recipe.mjs';
+export * from './input-tag-slot-recipe.mjs';
+export * from './modal-slot-recipe.mjs';
+export * from './upload-slot-recipe.mjs';
+export * from './upload-list-slot-recipe.mjs';
+export * from './dropzone-slot-recipe.mjs';
+export * from './banner-slot-recipe.mjs';
+export * from './banner-icon-slot-recipe.mjs';

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

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

package/recipes/input-tag-recipe.mjs

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputTagRecipeDefaultVariants = {}
+const inputTagRecipeCompoundVariants = []
+
+const inputTagRecipeSlotNames = [
+  [
+    "root",
+    "input-tag__root"
+  ],
+  [
+    "trigger",
+    "input-tag__trigger"
+  ],
+  [
+    "content",
+    "input-tag__content"
+  ]
+]
+const inputTagRecipeSlotFns = /* @__PURE__ */ inputTagRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputTagRecipeDefaultVariants, getSlotCompoundVariant(inputTagRecipeCompoundVariants, slotName))])
+
+const inputTagRecipeFn = (props = {}) => {
+  return Object.fromEntries(inputTagRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const inputTagRecipeVariantKeys = []
+
+export const inputTagRecipe = /* @__PURE__ */ Object.assign(inputTagRecipeFn, {
+  __recipe__: false,
+  __name__: 'inputTagRecipe',
+  raw: (props) => props,
+  variantKeys: inputTagRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, inputTagRecipeVariantKeys)
+  },
+})

package/recipes/input-tag-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 InputTagSlotRecipeVariant {
+  
+}
+
+type InputTagSlotRecipeVariantMap = {
+  [key in keyof InputTagSlotRecipeVariant]: Array<InputTagSlotRecipeVariant[key]>
+}
+
+export type InputTagSlotRecipeVariantProps = {
+  [key in keyof InputTagSlotRecipeVariant]?: ConditionalValue<InputTagSlotRecipeVariant[key]> | undefined
+}
+
+export interface InputTagSlotRecipeRecipe {
+  __type: InputTagSlotRecipeVariantProps
+  (props?: InputTagSlotRecipeVariantProps): Pretty<Record<"root" | "trigger" | "input" | "content" | "resetButton" | "dropdownButton" | "addButton" | "loading" | "empty" | "suggestionWrapper" | "suggestionLoading", string>>
+  raw: (props?: InputTagSlotRecipeVariantProps) => InputTagSlotRecipeVariantProps
+  variantMap: InputTagSlotRecipeVariantMap
+  variantKeys: Array<keyof InputTagSlotRecipeVariant>
+  splitVariantProps<Props extends InputTagSlotRecipeVariantProps>(props: Props): [InputTagSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof InputTagSlotRecipeVariantProps>>]
+}
+
+
+export declare const inputTagSlotRecipe: InputTagSlotRecipeRecipe