@pyck/styled-system 0.0.1

package/dist/recipes/number-input.mjs

@@ -0,0 +1,78 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const numberInputDefaultVariants = {
+  "size": "md",
+  "variant": "surface"
+}
+const numberInputCompoundVariants = []
+
+const numberInputSlotNames = [
+  [
+    "root",
+    "number-input__root"
+  ],
+  [
+    "label",
+    "number-input__label"
+  ],
+  [
+    "input",
+    "number-input__input"
+  ],
+  [
+    "control",
+    "number-input__control"
+  ],
+  [
+    "valueText",
+    "number-input__valueText"
+  ],
+  [
+    "incrementTrigger",
+    "number-input__incrementTrigger"
+  ],
+  [
+    "decrementTrigger",
+    "number-input__decrementTrigger"
+  ],
+  [
+    "scrubber",
+    "number-input__scrubber"
+  ]
+]
+const numberInputSlotFns = /* @__PURE__ */ numberInputSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, numberInputDefaultVariants, getSlotCompoundVariant(numberInputCompoundVariants, slotName))])
+
+const numberInputFn = memo((props = {}) => {
+  return Object.fromEntries(numberInputSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const numberInputVariantKeys = [
+  "size",
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...numberInputDefaultVariants, ...compact(variants) })
+
+export const numberInput = /* @__PURE__ */ Object.assign(numberInputFn, {
+  __recipe__: false,
+  __name__: 'numberInput',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: numberInputVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ],
+  "variant": [
+    "outline",
+    "surface"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, numberInputVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/pagination.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PaginationVariant {
+  
+}
+
+type PaginationVariantMap = {
+  [key in keyof PaginationVariant]: Array<PaginationVariant[key]>
+}
+
+type PaginationSlot = "root" | "item" | "ellipsis" | "firstTrigger" | "prevTrigger" | "nextTrigger" | "lastTrigger"
+
+export type PaginationVariantProps = {
+  [key in keyof PaginationVariant]?: ConditionalValue<PaginationVariant[key]> | undefined
+}
+
+export interface PaginationRecipe {
+  __slot: PaginationSlot
+  __type: PaginationVariantProps
+  (props?: PaginationVariantProps): Pretty<Record<PaginationSlot, string>>
+  raw: (props?: PaginationVariantProps) => PaginationVariantProps
+  variantMap: PaginationVariantMap
+  variantKeys: Array<keyof PaginationVariant>
+  splitVariantProps<Props extends PaginationVariantProps>(props: Props): [PaginationVariantProps, Pretty<DistributiveOmit<Props, keyof PaginationVariantProps>>]
+  getVariantProps: (props?: PaginationVariantProps) => PaginationVariantProps
+}
+
+
+export declare const pagination: PaginationRecipe

package/dist/recipes/pagination.mjs

@@ -0,0 +1,57 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const paginationDefaultVariants = {}
+const paginationCompoundVariants = []
+
+const paginationSlotNames = [
+  [
+    "root",
+    "pagination__root"
+  ],
+  [
+    "item",
+    "pagination__item"
+  ],
+  [
+    "ellipsis",
+    "pagination__ellipsis"
+  ],
+  [
+    "firstTrigger",
+    "pagination__firstTrigger"
+  ],
+  [
+    "prevTrigger",
+    "pagination__prevTrigger"
+  ],
+  [
+    "nextTrigger",
+    "pagination__nextTrigger"
+  ],
+  [
+    "lastTrigger",
+    "pagination__lastTrigger"
+  ]
+]
+const paginationSlotFns = /* @__PURE__ */ paginationSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, paginationDefaultVariants, getSlotCompoundVariant(paginationCompoundVariants, slotName))])
+
+const paginationFn = memo((props = {}) => {
+  return Object.fromEntries(paginationSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const paginationVariantKeys = []
+const getVariantProps = (variants) => ({ ...paginationDefaultVariants, ...compact(variants) })
+
+export const pagination = /* @__PURE__ */ Object.assign(paginationFn, {
+  __recipe__: false,
+  __name__: 'pagination',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: paginationVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, paginationVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/popover.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PopoverVariant {
+  
+}
+
+type PopoverVariantMap = {
+  [key in keyof PopoverVariant]: Array<PopoverVariant[key]>
+}
+
+type PopoverSlot = "arrow" | "arrowTip" | "anchor" | "trigger" | "indicator" | "positioner" | "content" | "title" | "description" | "closeTrigger" | "header" | "body" | "footer"
+
+export type PopoverVariantProps = {
+  [key in keyof PopoverVariant]?: ConditionalValue<PopoverVariant[key]> | undefined
+}
+
+export interface PopoverRecipe {
+  __slot: PopoverSlot
+  __type: PopoverVariantProps
+  (props?: PopoverVariantProps): Pretty<Record<PopoverSlot, string>>
+  raw: (props?: PopoverVariantProps) => PopoverVariantProps
+  variantMap: PopoverVariantMap
+  variantKeys: Array<keyof PopoverVariant>
+  splitVariantProps<Props extends PopoverVariantProps>(props: Props): [PopoverVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverVariantProps>>]
+  getVariantProps: (props?: PopoverVariantProps) => PopoverVariantProps
+}
+
+
+export declare const popover: PopoverRecipe

package/dist/recipes/popover.mjs

@@ -0,0 +1,81 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const popoverDefaultVariants = {}
+const popoverCompoundVariants = []
+
+const popoverSlotNames = [
+  [
+    "arrow",
+    "popover__arrow"
+  ],
+  [
+    "arrowTip",
+    "popover__arrowTip"
+  ],
+  [
+    "anchor",
+    "popover__anchor"
+  ],
+  [
+    "trigger",
+    "popover__trigger"
+  ],
+  [
+    "indicator",
+    "popover__indicator"
+  ],
+  [
+    "positioner",
+    "popover__positioner"
+  ],
+  [
+    "content",
+    "popover__content"
+  ],
+  [
+    "title",
+    "popover__title"
+  ],
+  [
+    "description",
+    "popover__description"
+  ],
+  [
+    "closeTrigger",
+    "popover__closeTrigger"
+  ],
+  [
+    "header",
+    "popover__header"
+  ],
+  [
+    "body",
+    "popover__body"
+  ],
+  [
+    "footer",
+    "popover__footer"
+  ]
+]
+const popoverSlotFns = /* @__PURE__ */ popoverSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, popoverDefaultVariants, getSlotCompoundVariant(popoverCompoundVariants, slotName))])
+
+const popoverFn = memo((props = {}) => {
+  return Object.fromEntries(popoverSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const popoverVariantKeys = []
+const getVariantProps = (variants) => ({ ...popoverDefaultVariants, ...compact(variants) })
+
+export const popover = /* @__PURE__ */ Object.assign(popoverFn, {
+  __recipe__: false,
+  __name__: 'popover',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: popoverVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, popoverVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/progress-circle.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProgressCircleVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type ProgressCircleVariantMap = {
+  [key in keyof ProgressCircleVariant]: Array<ProgressCircleVariant[key]>
+}
+
+type ProgressCircleSlot = "root" | "label" | "track" | "range" | "valueText" | "view" | "circle" | "circleTrack" | "circleRange"
+
+export type ProgressCircleVariantProps = {
+  [key in keyof ProgressCircleVariant]?: ConditionalValue<ProgressCircleVariant[key]> | undefined
+}
+
+export interface ProgressCircleRecipe {
+  __slot: ProgressCircleSlot
+  __type: ProgressCircleVariantProps
+  (props?: ProgressCircleVariantProps): Pretty<Record<ProgressCircleSlot, string>>
+  raw: (props?: ProgressCircleVariantProps) => ProgressCircleVariantProps
+  variantMap: ProgressCircleVariantMap
+  variantKeys: Array<keyof ProgressCircleVariant>
+  splitVariantProps<Props extends ProgressCircleVariantProps>(props: Props): [ProgressCircleVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressCircleVariantProps>>]
+  getVariantProps: (props?: ProgressCircleVariantProps) => ProgressCircleVariantProps
+}
+
+
+export declare const progressCircle: ProgressCircleRecipe

package/dist/recipes/progress-circle.mjs

@@ -0,0 +1,75 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const progressCircleDefaultVariants = {
+  "size": "md"
+}
+const progressCircleCompoundVariants = []
+
+const progressCircleSlotNames = [
+  [
+    "root",
+    "progress-circle__root"
+  ],
+  [
+    "label",
+    "progress-circle__label"
+  ],
+  [
+    "track",
+    "progress-circle__track"
+  ],
+  [
+    "range",
+    "progress-circle__range"
+  ],
+  [
+    "valueText",
+    "progress-circle__valueText"
+  ],
+  [
+    "view",
+    "progress-circle__view"
+  ],
+  [
+    "circle",
+    "progress-circle__circle"
+  ],
+  [
+    "circleTrack",
+    "progress-circle__circleTrack"
+  ],
+  [
+    "circleRange",
+    "progress-circle__circleRange"
+  ]
+]
+const progressCircleSlotFns = /* @__PURE__ */ progressCircleSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressCircleDefaultVariants, getSlotCompoundVariant(progressCircleCompoundVariants, slotName))])
+
+const progressCircleFn = memo((props = {}) => {
+  return Object.fromEntries(progressCircleSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const progressCircleVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...progressCircleDefaultVariants, ...compact(variants) })
+
+export const progressCircle = /* @__PURE__ */ Object.assign(progressCircleFn, {
+  __recipe__: false,
+  __name__: 'progressCircle',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: progressCircleVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, progressCircleVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/progress.d.ts

@@ -0,0 +1,44 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProgressVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "subtle"
+/**
+ * @default "rounded"
+ */
+shape: "square" | "rounded" | "full"
+striped: boolean
+animated: boolean
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+}
+
+type ProgressVariantMap = {
+  [key in keyof ProgressVariant]: Array<ProgressVariant[key]>
+}
+
+type ProgressSlot = "root" | "label" | "track" | "range" | "valueText" | "view" | "circle" | "circleTrack" | "circleRange"
+
+export type ProgressVariantProps = {
+  [key in keyof ProgressVariant]?: ConditionalValue<ProgressVariant[key]> | undefined
+}
+
+export interface ProgressRecipe {
+  __slot: ProgressSlot
+  __type: ProgressVariantProps
+  (props?: ProgressVariantProps): Pretty<Record<ProgressSlot, string>>
+  raw: (props?: ProgressVariantProps) => ProgressVariantProps
+  variantMap: ProgressVariantMap
+  variantKeys: Array<keyof ProgressVariant>
+  splitVariantProps<Props extends ProgressVariantProps>(props: Props): [ProgressVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressVariantProps>>]
+  getVariantProps: (props?: ProgressVariantProps) => ProgressVariantProps
+}
+
+
+export declare const progress: ProgressRecipe

package/dist/recipes/progress.mjs

@@ -0,0 +1,98 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const progressDefaultVariants = {
+  "variant": "solid",
+  "size": "md",
+  "shape": "rounded"
+}
+const progressCompoundVariants = []
+
+const progressSlotNames = [
+  [
+    "root",
+    "progress__root"
+  ],
+  [
+    "label",
+    "progress__label"
+  ],
+  [
+    "track",
+    "progress__track"
+  ],
+  [
+    "range",
+    "progress__range"
+  ],
+  [
+    "valueText",
+    "progress__valueText"
+  ],
+  [
+    "view",
+    "progress__view"
+  ],
+  [
+    "circle",
+    "progress__circle"
+  ],
+  [
+    "circleTrack",
+    "progress__circleTrack"
+  ],
+  [
+    "circleRange",
+    "progress__circleRange"
+  ]
+]
+const progressSlotFns = /* @__PURE__ */ progressSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressDefaultVariants, getSlotCompoundVariant(progressCompoundVariants, slotName))])
+
+const progressFn = memo((props = {}) => {
+  return Object.fromEntries(progressSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const progressVariantKeys = [
+  "variant",
+  "shape",
+  "striped",
+  "animated",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...progressDefaultVariants, ...compact(variants) })
+
+export const progress = /* @__PURE__ */ Object.assign(progressFn, {
+  __recipe__: false,
+  __name__: 'progress',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: progressVariantKeys,
+  variantMap: {
+  "variant": [
+    "solid",
+    "subtle"
+  ],
+  "shape": [
+    "square",
+    "rounded",
+    "full"
+  ],
+  "striped": [
+    "true"
+  ],
+  "animated": [
+    "true"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, progressVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/radio-card-group.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioCardGroupVariant {
+  /**
+ * @default "outline"
+ */
+variant: "subtle" | "outline" | "surface" | "solid"
+/**
+ * @default "md"
+ */
+size: "md"
+}
+
+type RadioCardGroupVariantMap = {
+  [key in keyof RadioCardGroupVariant]: Array<RadioCardGroupVariant[key]>
+}
+
+type RadioCardGroupSlot = "root" | "label" | "item" | "itemText" | "itemControl" | "indicator"
+
+export type RadioCardGroupVariantProps = {
+  [key in keyof RadioCardGroupVariant]?: ConditionalValue<RadioCardGroupVariant[key]> | undefined
+}
+
+export interface RadioCardGroupRecipe {
+  __slot: RadioCardGroupSlot
+  __type: RadioCardGroupVariantProps
+  (props?: RadioCardGroupVariantProps): Pretty<Record<RadioCardGroupSlot, string>>
+  raw: (props?: RadioCardGroupVariantProps) => RadioCardGroupVariantProps
+  variantMap: RadioCardGroupVariantMap
+  variantKeys: Array<keyof RadioCardGroupVariant>
+  splitVariantProps<Props extends RadioCardGroupVariantProps>(props: Props): [RadioCardGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioCardGroupVariantProps>>]
+  getVariantProps: (props?: RadioCardGroupVariantProps) => RadioCardGroupVariantProps
+}
+
+
+export declare const radioCardGroup: RadioCardGroupRecipe

package/dist/recipes/radio-card-group.mjs

@@ -0,0 +1,69 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioCardGroupDefaultVariants = {
+  "variant": "outline",
+  "size": "md"
+}
+const radioCardGroupCompoundVariants = []
+
+const radioCardGroupSlotNames = [
+  [
+    "root",
+    "radio-card-group__root"
+  ],
+  [
+    "label",
+    "radio-card-group__label"
+  ],
+  [
+    "item",
+    "radio-card-group__item"
+  ],
+  [
+    "itemText",
+    "radio-card-group__itemText"
+  ],
+  [
+    "itemControl",
+    "radio-card-group__itemControl"
+  ],
+  [
+    "indicator",
+    "radio-card-group__indicator"
+  ]
+]
+const radioCardGroupSlotFns = /* @__PURE__ */ radioCardGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioCardGroupDefaultVariants, getSlotCompoundVariant(radioCardGroupCompoundVariants, slotName))])
+
+const radioCardGroupFn = memo((props = {}) => {
+  return Object.fromEntries(radioCardGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const radioCardGroupVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...radioCardGroupDefaultVariants, ...compact(variants) })
+
+export const radioCardGroup = /* @__PURE__ */ Object.assign(radioCardGroupFn, {
+  __recipe__: false,
+  __name__: 'radioCardGroup',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: radioCardGroupVariantKeys,
+  variantMap: {
+  "variant": [
+    "subtle",
+    "outline",
+    "surface",
+    "solid"
+  ],
+  "size": [
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, radioCardGroupVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/radio-group.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioGroupVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type RadioGroupVariantMap = {
+  [key in keyof RadioGroupVariant]: Array<RadioGroupVariant[key]>
+}
+
+type RadioGroupSlot = "root" | "label" | "item" | "itemText" | "itemControl" | "indicator"
+
+export type RadioGroupVariantProps = {
+  [key in keyof RadioGroupVariant]?: ConditionalValue<RadioGroupVariant[key]> | undefined
+}
+
+export interface RadioGroupRecipe {
+  __slot: RadioGroupSlot
+  __type: RadioGroupVariantProps
+  (props?: RadioGroupVariantProps): Pretty<Record<RadioGroupSlot, string>>
+  raw: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
+  variantMap: RadioGroupVariantMap
+  variantKeys: Array<keyof RadioGroupVariant>
+  splitVariantProps<Props extends RadioGroupVariantProps>(props: Props): [RadioGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioGroupVariantProps>>]
+  getVariantProps: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
+}
+
+
+export declare const radioGroup: RadioGroupRecipe