@pyck/styled-system 0.0.1

package/dist/recipes/absolute-center.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AbsoluteCenterVariant {
+  /**
+ * @default "both"
+ */
+axis: "horizontal" | "vertical" | "both"
+}
+
+type AbsoluteCenterVariantMap = {
+  [key in keyof AbsoluteCenterVariant]: Array<AbsoluteCenterVariant[key]>
+}
+
+
+
+export type AbsoluteCenterVariantProps = {
+  [key in keyof AbsoluteCenterVariant]?: ConditionalValue<AbsoluteCenterVariant[key]> | undefined
+}
+
+export interface AbsoluteCenterRecipe {
+  
+  __type: AbsoluteCenterVariantProps
+  (props?: AbsoluteCenterVariantProps): string
+  raw: (props?: AbsoluteCenterVariantProps) => AbsoluteCenterVariantProps
+  variantMap: AbsoluteCenterVariantMap
+  variantKeys: Array<keyof AbsoluteCenterVariant>
+  splitVariantProps<Props extends AbsoluteCenterVariantProps>(props: Props): [AbsoluteCenterVariantProps, Pretty<DistributiveOmit<Props, keyof AbsoluteCenterVariantProps>>]
+  getVariantProps: (props?: AbsoluteCenterVariantProps) => AbsoluteCenterVariantProps
+}
+
+
+export declare const absoluteCenter: AbsoluteCenterRecipe

package/dist/recipes/absolute-center.mjs

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const absoluteCenterFn = /* @__PURE__ */ createRecipe('absolute-center', {
+  "axis": "both"
+}, [])
+
+const absoluteCenterVariantMap = {
+  "axis": [
+    "horizontal",
+    "vertical",
+    "both"
+  ]
+}
+
+const absoluteCenterVariantKeys = Object.keys(absoluteCenterVariantMap)
+
+export const absoluteCenter = /* @__PURE__ */ Object.assign(memo(absoluteCenterFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'absoluteCenter',
+  __getCompoundVariantCss__: absoluteCenterFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: absoluteCenterVariantKeys,
+  variantMap: absoluteCenterVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, absoluteCenterVariantKeys)
+  },
+  getVariantProps: absoluteCenterFn.getVariantProps,
+})

package/dist/recipes/action-bar.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ActionBarVariant {
+  
+}
+
+type ActionBarVariantMap = {
+  [key in keyof ActionBarVariant]: Array<ActionBarVariant[key]>
+}
+
+type ActionBarSlot = "positioner" | "content" | "selectionText" | "closeTrigger" | "separator"
+
+export type ActionBarVariantProps = {
+  [key in keyof ActionBarVariant]?: ConditionalValue<ActionBarVariant[key]> | undefined
+}
+
+export interface ActionBarRecipe {
+  __slot: ActionBarSlot
+  __type: ActionBarVariantProps
+  (props?: ActionBarVariantProps): Pretty<Record<ActionBarSlot, string>>
+  raw: (props?: ActionBarVariantProps) => ActionBarVariantProps
+  variantMap: ActionBarVariantMap
+  variantKeys: Array<keyof ActionBarVariant>
+  splitVariantProps<Props extends ActionBarVariantProps>(props: Props): [ActionBarVariantProps, Pretty<DistributiveOmit<Props, keyof ActionBarVariantProps>>]
+  getVariantProps: (props?: ActionBarVariantProps) => ActionBarVariantProps
+}
+
+
+export declare const actionBar: ActionBarRecipe

package/dist/recipes/action-bar.mjs

@@ -0,0 +1,49 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const actionBarDefaultVariants = {}
+const actionBarCompoundVariants = []
+
+const actionBarSlotNames = [
+  [
+    "positioner",
+    "action-bar__positioner"
+  ],
+  [
+    "content",
+    "action-bar__content"
+  ],
+  [
+    "selectionText",
+    "action-bar__selectionText"
+  ],
+  [
+    "closeTrigger",
+    "action-bar__closeTrigger"
+  ],
+  [
+    "separator",
+    "action-bar__separator"
+  ]
+]
+const actionBarSlotFns = /* @__PURE__ */ actionBarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, actionBarDefaultVariants, getSlotCompoundVariant(actionBarCompoundVariants, slotName))])
+
+const actionBarFn = memo((props = {}) => {
+  return Object.fromEntries(actionBarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const actionBarVariantKeys = []
+const getVariantProps = (variants) => ({ ...actionBarDefaultVariants, ...compact(variants) })
+
+export const actionBar = /* @__PURE__ */ Object.assign(actionBarFn, {
+  __recipe__: false,
+  __name__: 'actionBar',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: actionBarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, actionBarVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/avatar.d.ts

@@ -0,0 +1,43 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AvatarVariant {
+  /**
+ * @default "md"
+ */
+size: "full" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+/**
+ * @default "subtle"
+ */
+variant: "solid" | "surface" | "subtle" | "outline"
+borderless: boolean
+/**
+ * @default "full"
+ */
+shape: "square" | "rounded" | "full"
+}
+
+type AvatarVariantMap = {
+  [key in keyof AvatarVariant]: Array<AvatarVariant[key]>
+}
+
+type AvatarSlot = "root" | "image" | "fallback"
+
+export type AvatarVariantProps = {
+  [key in keyof AvatarVariant]?: ConditionalValue<AvatarVariant[key]> | undefined
+}
+
+export interface AvatarRecipe {
+  __slot: AvatarSlot
+  __type: AvatarVariantProps
+  (props?: AvatarVariantProps): Pretty<Record<AvatarSlot, string>>
+  raw: (props?: AvatarVariantProps) => AvatarVariantProps
+  variantMap: AvatarVariantMap
+  variantKeys: Array<keyof AvatarVariant>
+  splitVariantProps<Props extends AvatarVariantProps>(props: Props): [AvatarVariantProps, Pretty<DistributiveOmit<Props, keyof AvatarVariantProps>>]
+  getVariantProps: (props?: AvatarVariantProps) => AvatarVariantProps
+}
+
+
+export declare const avatar: AvatarRecipe

package/dist/recipes/avatar.mjs

@@ -0,0 +1,75 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const avatarDefaultVariants = {
+  "size": "md",
+  "shape": "full",
+  "variant": "subtle"
+}
+const avatarCompoundVariants = []
+
+const avatarSlotNames = [
+  [
+    "root",
+    "avatar__root"
+  ],
+  [
+    "image",
+    "avatar__image"
+  ],
+  [
+    "fallback",
+    "avatar__fallback"
+  ]
+]
+const avatarSlotFns = /* @__PURE__ */ avatarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, avatarDefaultVariants, getSlotCompoundVariant(avatarCompoundVariants, slotName))])
+
+const avatarFn = memo((props = {}) => {
+  return Object.fromEntries(avatarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const avatarVariantKeys = [
+  "size",
+  "variant",
+  "borderless",
+  "shape"
+]
+const getVariantProps = (variants) => ({ ...avatarDefaultVariants, ...compact(variants) })
+
+export const avatar = /* @__PURE__ */ Object.assign(avatarFn, {
+  __recipe__: false,
+  __name__: 'avatar',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: avatarVariantKeys,
+  variantMap: {
+  "size": [
+    "full",
+    "2xs",
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl"
+  ],
+  "variant": [
+    "solid",
+    "surface",
+    "subtle",
+    "outline"
+  ],
+  "borderless": [
+    "true"
+  ],
+  "shape": [
+    "square",
+    "rounded",
+    "full"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, avatarVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/badge.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BadgeVariant {
+  /**
+ * @default "subtle"
+ */
+variant: "solid" | "surface" | "subtle" | "outline"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg" | "xl"
+}
+
+type BadgeVariantMap = {
+  [key in keyof BadgeVariant]: Array<BadgeVariant[key]>
+}
+
+
+
+export type BadgeVariantProps = {
+  [key in keyof BadgeVariant]?: ConditionalValue<BadgeVariant[key]> | undefined
+}
+
+export interface BadgeRecipe {
+  
+  __type: BadgeVariantProps
+  (props?: BadgeVariantProps): string
+  raw: (props?: BadgeVariantProps) => BadgeVariantProps
+  variantMap: BadgeVariantMap
+  variantKeys: Array<keyof BadgeVariant>
+  splitVariantProps<Props extends BadgeVariantProps>(props: Props): [BadgeVariantProps, Pretty<DistributiveOmit<Props, keyof BadgeVariantProps>>]
+  getVariantProps: (props?: BadgeVariantProps) => BadgeVariantProps
+}
+
+
+export declare const badge: BadgeRecipe

package/dist/recipes/badge.mjs

@@ -0,0 +1,40 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const badgeFn = /* @__PURE__ */ createRecipe('badge', {
+  "variant": "subtle",
+  "size": "md"
+}, [])
+
+const badgeVariantMap = {
+  "variant": [
+    "solid",
+    "surface",
+    "subtle",
+    "outline"
+  ],
+  "size": [
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+}
+
+const badgeVariantKeys = Object.keys(badgeVariantMap)
+
+export const badge = /* @__PURE__ */ Object.assign(memo(badgeFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'badge',
+  __getCompoundVariantCss__: badgeFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: badgeVariantKeys,
+  variantMap: badgeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, badgeVariantKeys)
+  },
+  getVariantProps: badgeFn.getVariantProps,
+})

package/dist/recipes/breadcrumb.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BreadcrumbVariant {
+  /**
+ * @default "plain"
+ */
+variant: "underline" | "plain"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+}
+
+type BreadcrumbVariantMap = {
+  [key in keyof BreadcrumbVariant]: Array<BreadcrumbVariant[key]>
+}
+
+type BreadcrumbSlot = "root" | "list" | "link" | "item" | "separator" | "ellipsis"
+
+export type BreadcrumbVariantProps = {
+  [key in keyof BreadcrumbVariant]?: ConditionalValue<BreadcrumbVariant[key]> | undefined
+}
+
+export interface BreadcrumbRecipe {
+  __slot: BreadcrumbSlot
+  __type: BreadcrumbVariantProps
+  (props?: BreadcrumbVariantProps): Pretty<Record<BreadcrumbSlot, string>>
+  raw: (props?: BreadcrumbVariantProps) => BreadcrumbVariantProps
+  variantMap: BreadcrumbVariantMap
+  variantKeys: Array<keyof BreadcrumbVariant>
+  splitVariantProps<Props extends BreadcrumbVariantProps>(props: Props): [BreadcrumbVariantProps, Pretty<DistributiveOmit<Props, keyof BreadcrumbVariantProps>>]
+  getVariantProps: (props?: BreadcrumbVariantProps) => BreadcrumbVariantProps
+}
+
+
+export declare const breadcrumb: BreadcrumbRecipe

package/dist/recipes/breadcrumb.mjs

@@ -0,0 +1,70 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const breadcrumbDefaultVariants = {
+  "variant": "plain",
+  "size": "md"
+}
+const breadcrumbCompoundVariants = []
+
+const breadcrumbSlotNames = [
+  [
+    "root",
+    "breadcrumb__root"
+  ],
+  [
+    "list",
+    "breadcrumb__list"
+  ],
+  [
+    "link",
+    "breadcrumb__link"
+  ],
+  [
+    "item",
+    "breadcrumb__item"
+  ],
+  [
+    "separator",
+    "breadcrumb__separator"
+  ],
+  [
+    "ellipsis",
+    "breadcrumb__ellipsis"
+  ]
+]
+const breadcrumbSlotFns = /* @__PURE__ */ breadcrumbSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, breadcrumbDefaultVariants, getSlotCompoundVariant(breadcrumbCompoundVariants, slotName))])
+
+const breadcrumbFn = memo((props = {}) => {
+  return Object.fromEntries(breadcrumbSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const breadcrumbVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...breadcrumbDefaultVariants, ...compact(variants) })
+
+export const breadcrumb = /* @__PURE__ */ Object.assign(breadcrumbFn, {
+  __recipe__: false,
+  __name__: 'breadcrumb',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: breadcrumbVariantKeys,
+  variantMap: {
+  "variant": [
+    "underline",
+    "plain"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, breadcrumbVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/button.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ButtonVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "surface" | "subtle" | "outline" | "plain"
+/**
+ * @default "md"
+ */
+size: "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type ButtonVariantMap = {
+  [key in keyof ButtonVariant]: Array<ButtonVariant[key]>
+}
+
+
+
+export type ButtonVariantProps = {
+  [key in keyof ButtonVariant]?: ConditionalValue<ButtonVariant[key]> | undefined
+}
+
+export interface ButtonRecipe {
+  
+  __type: ButtonVariantProps
+  (props?: ButtonVariantProps): string
+  raw: (props?: ButtonVariantProps) => ButtonVariantProps
+  variantMap: ButtonVariantMap
+  variantKeys: Array<keyof ButtonVariant>
+  splitVariantProps<Props extends ButtonVariantProps>(props: Props): [ButtonVariantProps, Pretty<DistributiveOmit<Props, keyof ButtonVariantProps>>]
+  getVariantProps: (props?: ButtonVariantProps) => ButtonVariantProps
+}
+
+
+export declare const button: ButtonRecipe

package/dist/recipes/button.mjs

@@ -0,0 +1,44 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const buttonFn = /* @__PURE__ */ createRecipe('button', {
+  "variant": "solid",
+  "size": "md"
+}, [])
+
+const buttonVariantMap = {
+  "variant": [
+    "solid",
+    "surface",
+    "subtle",
+    "outline",
+    "plain"
+  ],
+  "size": [
+    "2xs",
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl"
+  ]
+}
+
+const buttonVariantKeys = Object.keys(buttonVariantMap)
+
+export const button = /* @__PURE__ */ Object.assign(memo(buttonFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'button',
+  __getCompoundVariantCss__: buttonFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: buttonVariantKeys,
+  variantMap: buttonVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, buttonVariantKeys)
+  },
+  getVariantProps: buttonFn.getVariantProps,
+})

package/dist/recipes/card.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CardVariant {
+  /**
+ * @default "outline"
+ */
+variant: "elevated" | "outline" | "subtle"
+}
+
+type CardVariantMap = {
+  [key in keyof CardVariant]: Array<CardVariant[key]>
+}
+
+type CardSlot = "root" | "header" | "body" | "footer" | "title" | "description"
+
+export type CardVariantProps = {
+  [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]> | undefined
+}
+
+export interface CardRecipe {
+  __slot: CardSlot
+  __type: CardVariantProps
+  (props?: CardVariantProps): Pretty<Record<CardSlot, string>>
+  raw: (props?: CardVariantProps) => CardVariantProps
+  variantMap: CardVariantMap
+  variantKeys: Array<keyof CardVariant>
+  splitVariantProps<Props extends CardVariantProps>(props: Props): [CardVariantProps, Pretty<DistributiveOmit<Props, keyof CardVariantProps>>]
+  getVariantProps: (props?: CardVariantProps) => CardVariantProps
+}
+
+
+export declare const card: CardRecipe

package/dist/recipes/card.mjs

@@ -0,0 +1,63 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const cardDefaultVariants = {
+  "variant": "outline"
+}
+const cardCompoundVariants = []
+
+const cardSlotNames = [
+  [
+    "root",
+    "card__root"
+  ],
+  [
+    "header",
+    "card__header"
+  ],
+  [
+    "body",
+    "card__body"
+  ],
+  [
+    "footer",
+    "card__footer"
+  ],
+  [
+    "title",
+    "card__title"
+  ],
+  [
+    "description",
+    "card__description"
+  ]
+]
+const cardSlotFns = /* @__PURE__ */ cardSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, cardDefaultVariants, getSlotCompoundVariant(cardCompoundVariants, slotName))])
+
+const cardFn = memo((props = {}) => {
+  return Object.fromEntries(cardSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const cardVariantKeys = [
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...cardDefaultVariants, ...compact(variants) })
+
+export const card = /* @__PURE__ */ Object.assign(cardFn, {
+  __recipe__: false,
+  __name__: 'card',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: cardVariantKeys,
+  variantMap: {
+  "variant": [
+    "elevated",
+    "outline",
+    "subtle"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, cardVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/carousel.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CarouselVariant {
+  inline: boolean
+/**
+ * @default "md"
+ */
+size: "md"
+}
+
+type CarouselVariantMap = {
+  [key in keyof CarouselVariant]: Array<CarouselVariant[key]>
+}
+
+type CarouselSlot = "root" | "itemGroup" | "item" | "control" | "nextTrigger" | "prevTrigger" | "indicatorGroup" | "indicator" | "autoplayTrigger" | "progressText" | "progressText" | "autoplayIndicator" | "image"
+
+export type CarouselVariantProps = {
+  [key in keyof CarouselVariant]?: ConditionalValue<CarouselVariant[key]> | undefined
+}
+
+export interface CarouselRecipe {
+  __slot: CarouselSlot
+  __type: CarouselVariantProps
+  (props?: CarouselVariantProps): Pretty<Record<CarouselSlot, string>>
+  raw: (props?: CarouselVariantProps) => CarouselVariantProps
+  variantMap: CarouselVariantMap
+  variantKeys: Array<keyof CarouselVariant>
+  splitVariantProps<Props extends CarouselVariantProps>(props: Props): [CarouselVariantProps, Pretty<DistributiveOmit<Props, keyof CarouselVariantProps>>]
+  getVariantProps: (props?: CarouselVariantProps) => CarouselVariantProps
+}
+
+
+export declare const carousel: CarouselRecipe