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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @mekari/pixel3-styled-system
 
+## 0.0.7-dev.1
+
+### Patch Changes
+
+- 15cc3bc: Update styled system
+
 ## 0.0.7-dev.0
 
 ### Patch Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mekari/pixel3-styled-system",
   "description": "This package is auto-generated by Panda CSS",
-  "version": "0.0.7-dev.0",
+  "version": "0.0.7-dev.1",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/recipes/calendar-panel-range-recipe.d.ts

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

package/recipes/calendar-panel-range-recipe.mjs

@@ -0,0 +1,22 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const calendarPanelRangeRecipeFn = /* @__PURE__ */ createRecipe('calendarPanelRange', {}, [])
+
+const calendarPanelRangeRecipeVariantMap = {}
+
+const calendarPanelRangeRecipeVariantKeys = Object.keys(calendarPanelRangeRecipeVariantMap)
+
+export const calendarPanelRangeRecipe = /* @__PURE__ */ Object.assign(memo(calendarPanelRangeRecipeFn), {
+  __recipe__: true,
+  __name__: 'calendarPanelRangeRecipe',
+  raw: (props) => props,
+  variantKeys: calendarPanelRangeRecipeVariantKeys,
+  variantMap: calendarPanelRangeRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, calendarPanelRangeRecipeVariantKeys)
+  },
+})

package/recipes/date-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 DateItemRecipeVariant {
+  status: "default" | "selected" | "range" | "today" | "notThisMonth" | "disabled" | "weekHoveredStart" | "weekHoveredMiddle" | "weekHoveredEnd" | "weekSelectedStart" | "weekSelectedMiddle" | "weekSelectedEnd"
+}
+
+type DateItemRecipeVariantMap = {
+  [key in keyof DateItemRecipeVariant]: Array<DateItemRecipeVariant[key]>
+}
+
+export type DateItemRecipeVariantProps = {
+  [key in keyof DateItemRecipeVariant]?: ConditionalValue<DateItemRecipeVariant[key]> | undefined
+}
+
+export interface DateItemRecipeRecipe {
+  __type: DateItemRecipeVariantProps
+  (props?: DateItemRecipeVariantProps): string
+  raw: (props?: DateItemRecipeVariantProps) => DateItemRecipeVariantProps
+  variantMap: DateItemRecipeVariantMap
+  variantKeys: Array<keyof DateItemRecipeVariant>
+  splitVariantProps<Props extends DateItemRecipeVariantProps>(props: Props): [DateItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DateItemRecipeVariantProps>>]
+}
+
+
+export declare const dateItemRecipe: DateItemRecipeRecipe

package/recipes/date-item-recipe.mjs

@@ -0,0 +1,37 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const dateItemRecipeFn = /* @__PURE__ */ createRecipe('dateItem', {}, [])
+
+const dateItemRecipeVariantMap = {
+  "status": [
+    "default",
+    "selected",
+    "range",
+    "today",
+    "notThisMonth",
+    "disabled",
+    "weekHoveredStart",
+    "weekHoveredMiddle",
+    "weekHoveredEnd",
+    "weekSelectedStart",
+    "weekSelectedMiddle",
+    "weekSelectedEnd"
+  ]
+}
+
+const dateItemRecipeVariantKeys = Object.keys(dateItemRecipeVariantMap)
+
+export const dateItemRecipe = /* @__PURE__ */ Object.assign(memo(dateItemRecipeFn), {
+  __recipe__: true,
+  __name__: 'dateItemRecipe',
+  raw: (props) => props,
+  variantKeys: dateItemRecipeVariantKeys,
+  variantMap: dateItemRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, dateItemRecipeVariantKeys)
+  },
+})

package/recipes/date-picker-recipe.d.ts

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

package/recipes/date-picker-recipe.mjs

@@ -0,0 +1,39 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs'
+import { createRecipe } from './create-recipe.mjs'
+
+const datePickerRecipeDefaultVariants = {}
+const datePickerRecipeCompoundVariants = []
+
+const datePickerRecipeSlotNames = [
+  ['root', 'datepicker__root'],
+  ['popoverContent', 'datepicker__popoverContent']
+]
+const datePickerRecipeSlotFns = /* @__PURE__ */ datePickerRecipeSlotNames.map(
+  ([slotName, slotKey]) => [
+    slotName,
+    createRecipe(
+      slotKey,
+      datePickerRecipeDefaultVariants,
+      getSlotCompoundVariant(datePickerRecipeCompoundVariants, slotName)
+    )
+  ]
+)
+
+const datePickerRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(
+    datePickerRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)])
+  )
+})
+
+const datePickerRecipeVariantKeys = []
+
+export const datePickerRecipe = /* @__PURE__ */ Object.assign(datePickerRecipeFn, {
+  __recipe__: false,
+  __name__: 'datePickerRecipe',
+  raw: (props) => props,
+  variantKeys: datePickerRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, datePickerRecipeVariantKeys)
+  }
+})

package/recipes/date-picker-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 DatePickerSlotRecipeVariant {
+  
+}
+
+type DatePickerSlotRecipeVariantMap = {
+  [key in keyof DatePickerSlotRecipeVariant]: Array<DatePickerSlotRecipeVariant[key]>
+}
+
+export type DatePickerSlotRecipeVariantProps = {
+  [key in keyof DatePickerSlotRecipeVariant]?: ConditionalValue<DatePickerSlotRecipeVariant[key]> | undefined
+}
+
+export interface DatePickerSlotRecipeRecipe {
+  __type: DatePickerSlotRecipeVariantProps
+  (props?: DatePickerSlotRecipeVariantProps): Pretty<Record<"root" | "popoverContent", string>>
+  raw: (props?: DatePickerSlotRecipeVariantProps) => DatePickerSlotRecipeVariantProps
+  variantMap: DatePickerSlotRecipeVariantMap
+  variantKeys: Array<keyof DatePickerSlotRecipeVariant>
+  splitVariantProps<Props extends DatePickerSlotRecipeVariantProps>(props: Props): [DatePickerSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DatePickerSlotRecipeVariantProps>>]
+}
+
+
+export declare const datePickerSlotRecipe: DatePickerSlotRecipeRecipe

package/recipes/date-picker-slot-recipe.mjs

@@ -0,0 +1,34 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const datePickerSlotRecipeDefaultVariants = {}
+const datePickerSlotRecipeCompoundVariants = []
+
+const datePickerSlotRecipeSlotNames = [
+  [
+    "root",
+    "datepicker__root"
+  ],
+  [
+    "popoverContent",
+    "datepicker__popoverContent"
+  ]
+]
+const datePickerSlotRecipeSlotFns = /* @__PURE__ */ datePickerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, datePickerSlotRecipeDefaultVariants, getSlotCompoundVariant(datePickerSlotRecipeCompoundVariants, slotName))])
+
+const datePickerSlotRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(datePickerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+})
+
+const datePickerSlotRecipeVariantKeys = []
+
+export const datePickerSlotRecipe = /* @__PURE__ */ Object.assign(datePickerSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'datePickerSlotRecipe',
+  raw: (props) => props,
+  variantKeys: datePickerSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, datePickerSlotRecipeVariantKeys)
+  },
+})

package/recipes/day-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 DayItemRecipeVariant {
+  
+}
+
+type DayItemRecipeVariantMap = {
+  [key in keyof DayItemRecipeVariant]: Array<DayItemRecipeVariant[key]>
+}
+
+export type DayItemRecipeVariantProps = {
+  [key in keyof DayItemRecipeVariant]?: ConditionalValue<DayItemRecipeVariant[key]> | undefined
+}
+
+export interface DayItemRecipeRecipe {
+  __type: DayItemRecipeVariantProps
+  (props?: DayItemRecipeVariantProps): string
+  raw: (props?: DayItemRecipeVariantProps) => DayItemRecipeVariantProps
+  variantMap: DayItemRecipeVariantMap
+  variantKeys: Array<keyof DayItemRecipeVariant>
+  splitVariantProps<Props extends DayItemRecipeVariantProps>(props: Props): [DayItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DayItemRecipeVariantProps>>]
+}
+
+
+export declare const dayItemRecipe: DayItemRecipeRecipe

package/recipes/day-item-recipe.mjs

@@ -0,0 +1,22 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const dayItemRecipeFn = /* @__PURE__ */ createRecipe('day', {}, [])
+
+const dayItemRecipeVariantMap = {}
+
+const dayItemRecipeVariantKeys = Object.keys(dayItemRecipeVariantMap)
+
+export const dayItemRecipe = /* @__PURE__ */ Object.assign(memo(dayItemRecipeFn), {
+  __recipe__: true,
+  __name__: 'dayItemRecipe',
+  raw: (props) => props,
+  variantKeys: dayItemRecipeVariantKeys,
+  variantMap: dayItemRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, dayItemRecipeVariantKeys)
+  },
+})

package/recipes/index.d.ts

@@ -21,6 +21,11 @@ export * from './banner-description-recipe';
 export * from './banner-link-recipe';
 export * from './banner-close-button-recipe';
 export * from './rtestyle-provider-recipe';
+export * from './calendar-panel-range-recipe';
+export * from './day-item-recipe';
+export * from './date-item-recipe';
+export * from './month-item-recipe';
+export * from './year-item-recipe';
 export * from './accordion';
 export * from './checkbox-slot-recipe';
 export * from './radio-slot-recipe';
@@ -46,4 +51,9 @@ export * from './segmented-control-slot-recipe';
 export * from './toast-slot-recipe';
 export * from './broadcast-slot-recipe';
 export * from './rich-text-editor-slot-recipe';
+export * from './date-picker-slot-recipe';
+export * from './table-date-slot-recipe';
+export * from './table-month-slot-recipe';
+export * from './table-year-slot-recipe';
+export * from './pinbar-slot-recipe';
 export * from './carousel-slot-recipe';

package/recipes/index.mjs

@@ -20,6 +20,11 @@ export * from './banner-description-recipe.mjs';
 export * from './banner-link-recipe.mjs';
 export * from './banner-close-button-recipe.mjs';
 export * from './rtestyle-provider-recipe.mjs';
+export * from './calendar-panel-range-recipe.mjs';
+export * from './day-item-recipe.mjs';
+export * from './date-item-recipe.mjs';
+export * from './month-item-recipe.mjs';
+export * from './year-item-recipe.mjs';
 export * from './accordion.mjs';
 export * from './checkbox-slot-recipe.mjs';
 export * from './radio-slot-recipe.mjs';
@@ -44,5 +49,10 @@ export * from './banner-icon-slot-recipe.mjs';
 export * from './segmented-control-slot-recipe.mjs';
 export * from './toast-slot-recipe.mjs';
 export * from './broadcast-slot-recipe.mjs';
-export * from './carousel-slot-recipe.mjs';
 export * from './rich-text-editor-slot-recipe.mjs';
+export * from './date-picker-slot-recipe.mjs';
+export * from './table-date-slot-recipe.mjs';
+export * from './table-month-slot-recipe.mjs';
+export * from './table-year-slot-recipe.mjs';
+export * from './pinbar-slot-recipe.mjs';
+export * from './carousel-slot-recipe.mjs';

package/recipes/month-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 MonthItemRecipeVariant {
+  status: "disabled" | "default" | "selected" | "range" | "today"
+}
+
+type MonthItemRecipeVariantMap = {
+  [key in keyof MonthItemRecipeVariant]: Array<MonthItemRecipeVariant[key]>
+}
+
+export type MonthItemRecipeVariantProps = {
+  [key in keyof MonthItemRecipeVariant]?: ConditionalValue<MonthItemRecipeVariant[key]> | undefined
+}
+
+export interface MonthItemRecipeRecipe {
+  __type: MonthItemRecipeVariantProps
+  (props?: MonthItemRecipeVariantProps): string
+  raw: (props?: MonthItemRecipeVariantProps) => MonthItemRecipeVariantProps
+  variantMap: MonthItemRecipeVariantMap
+  variantKeys: Array<keyof MonthItemRecipeVariant>
+  splitVariantProps<Props extends MonthItemRecipeVariantProps>(props: Props): [MonthItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthItemRecipeVariantProps>>]
+}
+
+
+export declare const monthItemRecipe: MonthItemRecipeRecipe

package/recipes/month-item-recipe.mjs

@@ -0,0 +1,30 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const monthItemRecipeFn = /* @__PURE__ */ createRecipe('monthItem', {}, [])
+
+const monthItemRecipeVariantMap = {
+  "status": [
+    "disabled",
+    "default",
+    "selected",
+    "range",
+    "today"
+  ]
+}
+
+const monthItemRecipeVariantKeys = Object.keys(monthItemRecipeVariantMap)
+
+export const monthItemRecipe = /* @__PURE__ */ Object.assign(memo(monthItemRecipeFn), {
+  __recipe__: true,
+  __name__: 'monthItemRecipe',
+  raw: (props) => props,
+  variantKeys: monthItemRecipeVariantKeys,
+  variantMap: monthItemRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, monthItemRecipeVariantKeys)
+  },
+})

package/recipes/pinbar-recipe.d.ts

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

package/recipes/pinbar-recipe.mjs

@@ -0,0 +1,37 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs'
+import { createRecipe } from './create-recipe.mjs'
+
+const pinbarRecipeDefaultVariants = {}
+const pinbarRecipeCompoundVariants = []
+
+const pinbarRecipeSlotNames = [
+  ['root', 'pinbar__root'],
+  ['pinbar', 'pinbar__pinbar']
+]
+const pinbarRecipeSlotFns = /* @__PURE__ */ pinbarRecipeSlotNames.map(([slotName, slotKey]) => [
+  slotName,
+  createRecipe(
+    slotKey,
+    pinbarRecipeDefaultVariants,
+    getSlotCompoundVariant(pinbarRecipeCompoundVariants, slotName)
+  )
+])
+
+const pinbarRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(
+    pinbarRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)])
+  )
+})
+
+const pinbarRecipeVariantKeys = []
+
+export const pinbarRecipe = /* @__PURE__ */ Object.assign(pinbarRecipeFn, {
+  __recipe__: false,
+  __name__: 'pinbarRecipe',
+  raw: (props) => props,
+  variantKeys: pinbarRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, pinbarRecipeVariantKeys)
+  }
+})

package/recipes/pinbar-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 PinbarSlotRecipeVariant {
+  
+}
+
+type PinbarSlotRecipeVariantMap = {
+  [key in keyof PinbarSlotRecipeVariant]: Array<PinbarSlotRecipeVariant[key]>
+}
+
+export type PinbarSlotRecipeVariantProps = {
+  [key in keyof PinbarSlotRecipeVariant]?: ConditionalValue<PinbarSlotRecipeVariant[key]> | undefined
+}
+
+export interface PinbarSlotRecipeRecipe {
+  __type: PinbarSlotRecipeVariantProps
+  (props?: PinbarSlotRecipeVariantProps): Pretty<Record<"root" | "pinbar", string>>
+  raw: (props?: PinbarSlotRecipeVariantProps) => PinbarSlotRecipeVariantProps
+  variantMap: PinbarSlotRecipeVariantMap
+  variantKeys: Array<keyof PinbarSlotRecipeVariant>
+  splitVariantProps<Props extends PinbarSlotRecipeVariantProps>(props: Props): [PinbarSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof PinbarSlotRecipeVariantProps>>]
+}
+
+
+export declare const pinbarSlotRecipe: PinbarSlotRecipeRecipe

package/recipes/pinbar-slot-recipe.mjs

@@ -0,0 +1,34 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const pinbarSlotRecipeDefaultVariants = {}
+const pinbarSlotRecipeCompoundVariants = []
+
+const pinbarSlotRecipeSlotNames = [
+  [
+    "root",
+    "pinbar__root"
+  ],
+  [
+    "pinbar",
+    "pinbar__pinbar"
+  ]
+]
+const pinbarSlotRecipeSlotFns = /* @__PURE__ */ pinbarSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, pinbarSlotRecipeDefaultVariants, getSlotCompoundVariant(pinbarSlotRecipeCompoundVariants, slotName))])
+
+const pinbarSlotRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(pinbarSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+})
+
+const pinbarSlotRecipeVariantKeys = []
+
+export const pinbarSlotRecipe = /* @__PURE__ */ Object.assign(pinbarSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'pinbarSlotRecipe',
+  raw: (props) => props,
+  variantKeys: pinbarSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, pinbarSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableDateRecipeVariant {
+  
+}
+
+type TableDateRecipeVariantMap = {
+  [key in keyof TableDateRecipeVariant]: Array<TableDateRecipeVariant[key]>
+}
+
+export type TableDateRecipeVariantProps = {
+  [key in keyof TableDateRecipeVariant]?: ConditionalValue<TableDateRecipeVariant[key]> | undefined
+}
+
+export interface TableDateRecipeRecipe {
+  __type: TableDateRecipeVariantProps
+  (props?: TableDateRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "dayWrapper" | "dateItemRoot" | "dateItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableDateRecipeVariantProps) => TableDateRecipeVariantProps
+  variantMap: TableDateRecipeVariantMap
+  variantKeys: Array<keyof TableDateRecipeVariant>
+  splitVariantProps<Props extends TableDateRecipeVariantProps>(props: Props): [TableDateRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableDateRecipeVariantProps>>]
+}
+
+
+export declare const tableDateRecipe: TableDateRecipeRecipe

package/recipes/table-date-recipe.mjs

@@ -0,0 +1,43 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs'
+import { createRecipe } from './create-recipe.mjs'
+
+const tableDateRecipeDefaultVariants = {}
+const tableDateRecipeCompoundVariants = []
+
+const tableDateRecipeSlotNames = [
+  ['headerRoot', 'tableDate__headerRoot'],
+  ['headerLabel', 'tableDate__headerLabel'],
+  ['dayWrapper', 'tableDate__dayWrapper'],
+  ['dateItemRoot', 'tableDate__dateItemRoot'],
+  ['dateItemWrapper', 'tableDate__dateItemWrapper'],
+  ['shortcutLabelWrapper', 'tableDate__shortcutLabelWrapper']
+]
+const tableDateRecipeSlotFns = /* @__PURE__ */ tableDateRecipeSlotNames.map(
+  ([slotName, slotKey]) => [
+    slotName,
+    createRecipe(
+      slotKey,
+      tableDateRecipeDefaultVariants,
+      getSlotCompoundVariant(tableDateRecipeCompoundVariants, slotName)
+    )
+  ]
+)
+
+const tableDateRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(
+    tableDateRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)])
+  )
+})
+
+const tableDateRecipeVariantKeys = []
+
+export const tableDateRecipe = /* @__PURE__ */ Object.assign(tableDateRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableDateRecipe',
+  raw: (props) => props,
+  variantKeys: tableDateRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableDateRecipeVariantKeys)
+  }
+})

package/recipes/table-date-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 TableDateSlotRecipeVariant {
+  
+}
+
+type TableDateSlotRecipeVariantMap = {
+  [key in keyof TableDateSlotRecipeVariant]: Array<TableDateSlotRecipeVariant[key]>
+}
+
+export type TableDateSlotRecipeVariantProps = {
+  [key in keyof TableDateSlotRecipeVariant]?: ConditionalValue<TableDateSlotRecipeVariant[key]> | undefined
+}
+
+export interface TableDateSlotRecipeRecipe {
+  __type: TableDateSlotRecipeVariantProps
+  (props?: TableDateSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "dayWrapper" | "dateItemRoot" | "dateItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableDateSlotRecipeVariantProps) => TableDateSlotRecipeVariantProps
+  variantMap: TableDateSlotRecipeVariantMap
+  variantKeys: Array<keyof TableDateSlotRecipeVariant>
+  splitVariantProps<Props extends TableDateSlotRecipeVariantProps>(props: Props): [TableDateSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableDateSlotRecipeVariantProps>>]
+}
+
+
+export declare const tableDateSlotRecipe: TableDateSlotRecipeRecipe

package/recipes/table-date-slot-recipe.mjs

@@ -0,0 +1,50 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableDateSlotRecipeDefaultVariants = {}
+const tableDateSlotRecipeCompoundVariants = []
+
+const tableDateSlotRecipeSlotNames = [
+  [
+    "headerRoot",
+    "tableDate__headerRoot"
+  ],
+  [
+    "headerLabel",
+    "tableDate__headerLabel"
+  ],
+  [
+    "dayWrapper",
+    "tableDate__dayWrapper"
+  ],
+  [
+    "dateItemRoot",
+    "tableDate__dateItemRoot"
+  ],
+  [
+    "dateItemWrapper",
+    "tableDate__dateItemWrapper"
+  ],
+  [
+    "shortcutLabelWrapper",
+    "tableDate__shortcutLabelWrapper"
+  ]
+]
+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)]))
+})
+
+const tableDateSlotRecipeVariantKeys = []
+
+export const tableDateSlotRecipe = /* @__PURE__ */ Object.assign(tableDateSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableDateSlotRecipe',
+  raw: (props) => props,
+  variantKeys: tableDateSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableDateSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableMonthRecipeVariant {
+  
+}
+
+type TableMonthRecipeVariantMap = {
+  [key in keyof TableMonthRecipeVariant]: Array<TableMonthRecipeVariant[key]>
+}
+
+export type TableMonthRecipeVariantProps = {
+  [key in keyof TableMonthRecipeVariant]?: ConditionalValue<TableMonthRecipeVariant[key]> | undefined
+}
+
+export interface TableMonthRecipeRecipe {
+  __type: TableMonthRecipeVariantProps
+  (props?: TableMonthRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "monthItemRoot" | "monthItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableMonthRecipeVariantProps) => TableMonthRecipeVariantProps
+  variantMap: TableMonthRecipeVariantMap
+  variantKeys: Array<keyof TableMonthRecipeVariant>
+  splitVariantProps<Props extends TableMonthRecipeVariantProps>(props: Props): [TableMonthRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableMonthRecipeVariantProps>>]
+}
+
+
+export declare const tableMonthRecipe: TableMonthRecipeRecipe

package/recipes/table-month-recipe.mjs

@@ -0,0 +1,42 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs'
+import { createRecipe } from './create-recipe.mjs'
+
+const tableMonthRecipeDefaultVariants = {}
+const tableMonthRecipeCompoundVariants = []
+
+const tableMonthRecipeSlotNames = [
+  ['headerRoot', 'tableMonth__headerRoot'],
+  ['headerLabel', 'tableMonth__headerLabel'],
+  ['monthItemRoot', 'tableMonth__monthItemRoot'],
+  ['monthItemWrapper', 'tableMonth__monthItemWrapper'],
+  ['shortcutLabelWrapper', 'tableMonth__shortcutLabelWrapper']
+]
+const tableMonthRecipeSlotFns = /* @__PURE__ */ tableMonthRecipeSlotNames.map(
+  ([slotName, slotKey]) => [
+    slotName,
+    createRecipe(
+      slotKey,
+      tableMonthRecipeDefaultVariants,
+      getSlotCompoundVariant(tableMonthRecipeCompoundVariants, slotName)
+    )
+  ]
+)
+
+const tableMonthRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(
+    tableMonthRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)])
+  )
+})
+
+const tableMonthRecipeVariantKeys = []
+
+export const tableMonthRecipe = /* @__PURE__ */ Object.assign(tableMonthRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableMonthRecipe',
+  raw: (props) => props,
+  variantKeys: tableMonthRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableMonthRecipeVariantKeys)
+  }
+})

package/recipes/table-month-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 TableMonthSlotRecipeVariant {
+  
+}
+
+type TableMonthSlotRecipeVariantMap = {
+  [key in keyof TableMonthSlotRecipeVariant]: Array<TableMonthSlotRecipeVariant[key]>
+}
+
+export type TableMonthSlotRecipeVariantProps = {
+  [key in keyof TableMonthSlotRecipeVariant]?: ConditionalValue<TableMonthSlotRecipeVariant[key]> | undefined
+}
+
+export interface TableMonthSlotRecipeRecipe {
+  __type: TableMonthSlotRecipeVariantProps
+  (props?: TableMonthSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "monthItemRoot" | "monthItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableMonthSlotRecipeVariantProps) => TableMonthSlotRecipeVariantProps
+  variantMap: TableMonthSlotRecipeVariantMap
+  variantKeys: Array<keyof TableMonthSlotRecipeVariant>
+  splitVariantProps<Props extends TableMonthSlotRecipeVariantProps>(props: Props): [TableMonthSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableMonthSlotRecipeVariantProps>>]
+}
+
+
+export declare const tableMonthSlotRecipe: TableMonthSlotRecipeRecipe

package/recipes/table-month-slot-recipe.mjs

@@ -0,0 +1,46 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableMonthSlotRecipeDefaultVariants = {}
+const tableMonthSlotRecipeCompoundVariants = []
+
+const tableMonthSlotRecipeSlotNames = [
+  [
+    "headerRoot",
+    "tableMonth__headerRoot"
+  ],
+  [
+    "headerLabel",
+    "tableMonth__headerLabel"
+  ],
+  [
+    "monthItemRoot",
+    "tableMonth__monthItemRoot"
+  ],
+  [
+    "monthItemWrapper",
+    "tableMonth__monthItemWrapper"
+  ],
+  [
+    "shortcutLabelWrapper",
+    "tableMonth__shortcutLabelWrapper"
+  ]
+]
+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)]))
+})
+
+const tableMonthSlotRecipeVariantKeys = []
+
+export const tableMonthSlotRecipe = /* @__PURE__ */ Object.assign(tableMonthSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableMonthSlotRecipe',
+  raw: (props) => props,
+  variantKeys: tableMonthSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableMonthSlotRecipeVariantKeys)
+  },
+})

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

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableYearRecipeVariant {
+  
+}
+
+type TableYearRecipeVariantMap = {
+  [key in keyof TableYearRecipeVariant]: Array<TableYearRecipeVariant[key]>
+}
+
+export type TableYearRecipeVariantProps = {
+  [key in keyof TableYearRecipeVariant]?: ConditionalValue<TableYearRecipeVariant[key]> | undefined
+}
+
+export interface TableYearRecipeRecipe {
+  __type: TableYearRecipeVariantProps
+  (props?: TableYearRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "yearItemRoot" | "yearItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableYearRecipeVariantProps) => TableYearRecipeVariantProps
+  variantMap: TableYearRecipeVariantMap
+  variantKeys: Array<keyof TableYearRecipeVariant>
+  splitVariantProps<Props extends TableYearRecipeVariantProps>(props: Props): [TableYearRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableYearRecipeVariantProps>>]
+}
+
+
+export declare const tableYearRecipe: TableYearRecipeRecipe

package/recipes/table-year-recipe.mjs

@@ -0,0 +1,42 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs'
+import { createRecipe } from './create-recipe.mjs'
+
+const tableYearRecipeDefaultVariants = {}
+const tableYearRecipeCompoundVariants = []
+
+const tableYearRecipeSlotNames = [
+  ['headerRoot', 'tableYear__headerRoot'],
+  ['headerLabel', 'tableYear__headerLabel'],
+  ['yearItemRoot', 'tableYear__yearItemRoot'],
+  ['yearItemWrapper', 'tableYear__yearItemWrapper'],
+  ['shortcutLabelWrapper', 'tableYear__shortcutLabelWrapper']
+]
+const tableYearRecipeSlotFns = /* @__PURE__ */ tableYearRecipeSlotNames.map(
+  ([slotName, slotKey]) => [
+    slotName,
+    createRecipe(
+      slotKey,
+      tableYearRecipeDefaultVariants,
+      getSlotCompoundVariant(tableYearRecipeCompoundVariants, slotName)
+    )
+  ]
+)
+
+const tableYearRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(
+    tableYearRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)])
+  )
+})
+
+const tableYearRecipeVariantKeys = []
+
+export const tableYearRecipe = /* @__PURE__ */ Object.assign(tableYearRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableYearRecipe',
+  raw: (props) => props,
+  variantKeys: tableYearRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableYearRecipeVariantKeys)
+  }
+})

package/recipes/table-year-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 TableYearSlotRecipeVariant {
+  
+}
+
+type TableYearSlotRecipeVariantMap = {
+  [key in keyof TableYearSlotRecipeVariant]: Array<TableYearSlotRecipeVariant[key]>
+}
+
+export type TableYearSlotRecipeVariantProps = {
+  [key in keyof TableYearSlotRecipeVariant]?: ConditionalValue<TableYearSlotRecipeVariant[key]> | undefined
+}
+
+export interface TableYearSlotRecipeRecipe {
+  __type: TableYearSlotRecipeVariantProps
+  (props?: TableYearSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "yearItemRoot" | "yearItemWrapper" | "shortcutLabelWrapper", string>>
+  raw: (props?: TableYearSlotRecipeVariantProps) => TableYearSlotRecipeVariantProps
+  variantMap: TableYearSlotRecipeVariantMap
+  variantKeys: Array<keyof TableYearSlotRecipeVariant>
+  splitVariantProps<Props extends TableYearSlotRecipeVariantProps>(props: Props): [TableYearSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableYearSlotRecipeVariantProps>>]
+}
+
+
+export declare const tableYearSlotRecipe: TableYearSlotRecipeRecipe

package/recipes/table-year-slot-recipe.mjs

@@ -0,0 +1,46 @@
+import { getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableYearSlotRecipeDefaultVariants = {}
+const tableYearSlotRecipeCompoundVariants = []
+
+const tableYearSlotRecipeSlotNames = [
+  [
+    "headerRoot",
+    "tableYear__headerRoot"
+  ],
+  [
+    "headerLabel",
+    "tableYear__headerLabel"
+  ],
+  [
+    "yearItemRoot",
+    "tableYear__yearItemRoot"
+  ],
+  [
+    "yearItemWrapper",
+    "tableYear__yearItemWrapper"
+  ],
+  [
+    "shortcutLabelWrapper",
+    "tableYear__shortcutLabelWrapper"
+  ]
+]
+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)]))
+})
+
+const tableYearSlotRecipeVariantKeys = []
+
+export const tableYearSlotRecipe = /* @__PURE__ */ Object.assign(tableYearSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'tableYearSlotRecipe',
+  raw: (props) => props,
+  variantKeys: tableYearSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableYearSlotRecipeVariantKeys)
+  },
+})

package/recipes/year-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 YearItemRecipeVariant {
+  status: "disabled" | "default" | "selected" | "range" | "today"
+}
+
+type YearItemRecipeVariantMap = {
+  [key in keyof YearItemRecipeVariant]: Array<YearItemRecipeVariant[key]>
+}
+
+export type YearItemRecipeVariantProps = {
+  [key in keyof YearItemRecipeVariant]?: ConditionalValue<YearItemRecipeVariant[key]> | undefined
+}
+
+export interface YearItemRecipeRecipe {
+  __type: YearItemRecipeVariantProps
+  (props?: YearItemRecipeVariantProps): string
+  raw: (props?: YearItemRecipeVariantProps) => YearItemRecipeVariantProps
+  variantMap: YearItemRecipeVariantMap
+  variantKeys: Array<keyof YearItemRecipeVariant>
+  splitVariantProps<Props extends YearItemRecipeVariantProps>(props: Props): [YearItemRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof YearItemRecipeVariantProps>>]
+}
+
+
+export declare const yearItemRecipe: YearItemRecipeRecipe

package/recipes/year-item-recipe.mjs

@@ -0,0 +1,30 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const yearItemRecipeFn = /* @__PURE__ */ createRecipe('yearItem', {}, [])
+
+const yearItemRecipeVariantMap = {
+  "status": [
+    "disabled",
+    "default",
+    "selected",
+    "range",
+    "today"
+  ]
+}
+
+const yearItemRecipeVariantKeys = Object.keys(yearItemRecipeVariantMap)
+
+export const yearItemRecipe = /* @__PURE__ */ Object.assign(memo(yearItemRecipeFn), {
+  __recipe__: true,
+  __name__: 'yearItemRecipe',
+  raw: (props) => props,
+  variantKeys: yearItemRecipeVariantKeys,
+  variantMap: yearItemRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, yearItemRecipeVariantKeys)
+  },
+})