@pyck/styled-system 0.0.1

package/dist/recipes/radio-group.mjs

@@ -0,0 +1,68 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioGroupDefaultVariants = {
+  "variant": "solid",
+  "size": "md"
+}
+const radioGroupCompoundVariants = []
+
+const radioGroupSlotNames = [
+  [
+    "root",
+    "radio-group__root"
+  ],
+  [
+    "label",
+    "radio-group__label"
+  ],
+  [
+    "item",
+    "radio-group__item"
+  ],
+  [
+    "itemText",
+    "radio-group__itemText"
+  ],
+  [
+    "itemControl",
+    "radio-group__itemControl"
+  ],
+  [
+    "indicator",
+    "radio-group__indicator"
+  ]
+]
+const radioGroupSlotFns = /* @__PURE__ */ radioGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioGroupDefaultVariants, getSlotCompoundVariant(radioGroupCompoundVariants, slotName))])
+
+const radioGroupFn = memo((props = {}) => {
+  return Object.fromEntries(radioGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const radioGroupVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...radioGroupDefaultVariants, ...compact(variants) })
+
+export const radioGroup = /* @__PURE__ */ Object.assign(radioGroupFn, {
+  __recipe__: false,
+  __name__: 'radioGroup',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: radioGroupVariantKeys,
+  variantMap: {
+  "variant": [
+    "solid"
+  ],
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, radioGroupVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/scroll-area.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ScrollAreaVariant {
+  /**
+ * @default "auto"
+ */
+scrollbar: "auto" | "visible"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+}
+
+type ScrollAreaVariantMap = {
+  [key in keyof ScrollAreaVariant]: Array<ScrollAreaVariant[key]>
+}
+
+type ScrollAreaSlot = "root" | "viewport" | "content" | "scrollbar" | "thumb" | "corner"
+
+export type ScrollAreaVariantProps = {
+  [key in keyof ScrollAreaVariant]?: ConditionalValue<ScrollAreaVariant[key]> | undefined
+}
+
+export interface ScrollAreaRecipe {
+  __slot: ScrollAreaSlot
+  __type: ScrollAreaVariantProps
+  (props?: ScrollAreaVariantProps): Pretty<Record<ScrollAreaSlot, string>>
+  raw: (props?: ScrollAreaVariantProps) => ScrollAreaVariantProps
+  variantMap: ScrollAreaVariantMap
+  variantKeys: Array<keyof ScrollAreaVariant>
+  splitVariantProps<Props extends ScrollAreaVariantProps>(props: Props): [ScrollAreaVariantProps, Pretty<DistributiveOmit<Props, keyof ScrollAreaVariantProps>>]
+  getVariantProps: (props?: ScrollAreaVariantProps) => ScrollAreaVariantProps
+}
+
+
+export declare const scrollArea: ScrollAreaRecipe

package/dist/recipes/scroll-area.mjs

@@ -0,0 +1,70 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const scrollAreaDefaultVariants = {
+  "size": "md",
+  "scrollbar": "auto"
+}
+const scrollAreaCompoundVariants = []
+
+const scrollAreaSlotNames = [
+  [
+    "root",
+    "scroll-area__root"
+  ],
+  [
+    "viewport",
+    "scroll-area__viewport"
+  ],
+  [
+    "content",
+    "scroll-area__content"
+  ],
+  [
+    "scrollbar",
+    "scroll-area__scrollbar"
+  ],
+  [
+    "thumb",
+    "scroll-area__thumb"
+  ],
+  [
+    "corner",
+    "scroll-area__corner"
+  ]
+]
+const scrollAreaSlotFns = /* @__PURE__ */ scrollAreaSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, scrollAreaDefaultVariants, getSlotCompoundVariant(scrollAreaCompoundVariants, slotName))])
+
+const scrollAreaFn = memo((props = {}) => {
+  return Object.fromEntries(scrollAreaSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const scrollAreaVariantKeys = [
+  "scrollbar",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...scrollAreaDefaultVariants, ...compact(variants) })
+
+export const scrollArea = /* @__PURE__ */ Object.assign(scrollAreaFn, {
+  __recipe__: false,
+  __name__: 'scrollArea',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: scrollAreaVariantKeys,
+  variantMap: {
+  "scrollbar": [
+    "auto",
+    "visible"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, scrollAreaVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SegmentGroupVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+fitted: boolean
+}
+
+type SegmentGroupVariantMap = {
+  [key in keyof SegmentGroupVariant]: Array<SegmentGroupVariant[key]>
+}
+
+type SegmentGroupSlot = "root" | "label" | "item" | "itemText" | "itemControl" | "indicator"
+
+export type SegmentGroupVariantProps = {
+  [key in keyof SegmentGroupVariant]?: ConditionalValue<SegmentGroupVariant[key]> | undefined
+}
+
+export interface SegmentGroupRecipe {
+  __slot: SegmentGroupSlot
+  __type: SegmentGroupVariantProps
+  (props?: SegmentGroupVariantProps): Pretty<Record<SegmentGroupSlot, string>>
+  raw: (props?: SegmentGroupVariantProps) => SegmentGroupVariantProps
+  variantMap: SegmentGroupVariantMap
+  variantKeys: Array<keyof SegmentGroupVariant>
+  splitVariantProps<Props extends SegmentGroupVariantProps>(props: Props): [SegmentGroupVariantProps, Pretty<DistributiveOmit<Props, keyof SegmentGroupVariantProps>>]
+  getVariantProps: (props?: SegmentGroupVariantProps) => SegmentGroupVariantProps
+}
+
+
+export declare const segmentGroup: SegmentGroupRecipe

package/dist/recipes/segment-group.mjs

@@ -0,0 +1,69 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const segmentGroupDefaultVariants = {
+  "size": "md"
+}
+const segmentGroupCompoundVariants = []
+
+const segmentGroupSlotNames = [
+  [
+    "root",
+    "segment-group__root"
+  ],
+  [
+    "label",
+    "segment-group__label"
+  ],
+  [
+    "item",
+    "segment-group__item"
+  ],
+  [
+    "itemText",
+    "segment-group__itemText"
+  ],
+  [
+    "itemControl",
+    "segment-group__itemControl"
+  ],
+  [
+    "indicator",
+    "segment-group__indicator"
+  ]
+]
+const segmentGroupSlotFns = /* @__PURE__ */ segmentGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, segmentGroupDefaultVariants, getSlotCompoundVariant(segmentGroupCompoundVariants, slotName))])
+
+const segmentGroupFn = memo((props = {}) => {
+  return Object.fromEntries(segmentGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const segmentGroupVariantKeys = [
+  "size",
+  "fitted"
+]
+const getVariantProps = (variants) => ({ ...segmentGroupDefaultVariants, ...compact(variants) })
+
+export const segmentGroup = /* @__PURE__ */ Object.assign(segmentGroupFn, {
+  __recipe__: false,
+  __name__: 'segmentGroup',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: segmentGroupVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ],
+  "fitted": [
+    "true"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, segmentGroupVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/select.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SelectVariant {
+  /**
+ * @default "surface"
+ */
+variant: "outline" | "surface"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+}
+
+type SelectVariantMap = {
+  [key in keyof SelectVariant]: Array<SelectVariant[key]>
+}
+
+type SelectSlot = "label" | "positioner" | "trigger" | "indicator" | "clearTrigger" | "item" | "itemText" | "itemIndicator" | "itemGroup" | "itemGroupLabel" | "list" | "content" | "root" | "control" | "valueText" | "indicatorGroup"
+
+export type SelectVariantProps = {
+  [key in keyof SelectVariant]?: ConditionalValue<SelectVariant[key]> | undefined
+}
+
+export interface SelectRecipe {
+  __slot: SelectSlot
+  __type: SelectVariantProps
+  (props?: SelectVariantProps): Pretty<Record<SelectSlot, string>>
+  raw: (props?: SelectVariantProps) => SelectVariantProps
+  variantMap: SelectVariantMap
+  variantKeys: Array<keyof SelectVariant>
+  splitVariantProps<Props extends SelectVariantProps>(props: Props): [SelectVariantProps, Pretty<DistributiveOmit<Props, keyof SelectVariantProps>>]
+  getVariantProps: (props?: SelectVariantProps) => SelectVariantProps
+}
+
+
+export declare const select: SelectRecipe

package/dist/recipes/select.mjs

@@ -0,0 +1,111 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const selectDefaultVariants = {
+  "size": "md",
+  "variant": "surface"
+}
+const selectCompoundVariants = []
+
+const selectSlotNames = [
+  [
+    "label",
+    "select__label"
+  ],
+  [
+    "positioner",
+    "select__positioner"
+  ],
+  [
+    "trigger",
+    "select__trigger"
+  ],
+  [
+    "indicator",
+    "select__indicator"
+  ],
+  [
+    "clearTrigger",
+    "select__clearTrigger"
+  ],
+  [
+    "item",
+    "select__item"
+  ],
+  [
+    "itemText",
+    "select__itemText"
+  ],
+  [
+    "itemIndicator",
+    "select__itemIndicator"
+  ],
+  [
+    "itemGroup",
+    "select__itemGroup"
+  ],
+  [
+    "itemGroupLabel",
+    "select__itemGroupLabel"
+  ],
+  [
+    "list",
+    "select__list"
+  ],
+  [
+    "content",
+    "select__content"
+  ],
+  [
+    "root",
+    "select__root"
+  ],
+  [
+    "control",
+    "select__control"
+  ],
+  [
+    "valueText",
+    "select__valueText"
+  ],
+  [
+    "indicatorGroup",
+    "select__indicatorGroup"
+  ]
+]
+const selectSlotFns = /* @__PURE__ */ selectSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, selectDefaultVariants, getSlotCompoundVariant(selectCompoundVariants, slotName))])
+
+const selectFn = memo((props = {}) => {
+  return Object.fromEntries(selectSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const selectVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...selectDefaultVariants, ...compact(variants) })
+
+export const select = /* @__PURE__ */ Object.assign(selectFn, {
+  __recipe__: false,
+  __name__: 'select',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: selectVariantKeys,
+  variantMap: {
+  "variant": [
+    "outline",
+    "surface"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, selectVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/skeleton.d.ts

@@ -0,0 +1,39 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SkeletonVariant {
+  /**
+ * @default true
+ */
+loading: boolean
+circle: boolean
+/**
+ * @default "pulse"
+ */
+variant: "pulse" | "shine" | "none"
+}
+
+type SkeletonVariantMap = {
+  [key in keyof SkeletonVariant]: Array<SkeletonVariant[key]>
+}
+
+
+
+export type SkeletonVariantProps = {
+  [key in keyof SkeletonVariant]?: ConditionalValue<SkeletonVariant[key]> | undefined
+}
+
+export interface SkeletonRecipe {
+  
+  __type: SkeletonVariantProps
+  (props?: SkeletonVariantProps): string
+  raw: (props?: SkeletonVariantProps) => SkeletonVariantProps
+  variantMap: SkeletonVariantMap
+  variantKeys: Array<keyof SkeletonVariant>
+  splitVariantProps<Props extends SkeletonVariantProps>(props: Props): [SkeletonVariantProps, Pretty<DistributiveOmit<Props, keyof SkeletonVariantProps>>]
+  getVariantProps: (props?: SkeletonVariantProps) => SkeletonVariantProps
+}
+
+
+export declare const skeleton: SkeletonRecipe

package/dist/recipes/skeleton.mjs

@@ -0,0 +1,40 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const skeletonFn = /* @__PURE__ */ createRecipe('skeleton', {
+  "variant": "pulse",
+  "loading": true
+}, [])
+
+const skeletonVariantMap = {
+  "loading": [
+    "true",
+    "false"
+  ],
+  "circle": [
+    "true"
+  ],
+  "variant": [
+    "pulse",
+    "shine",
+    "none"
+  ]
+}
+
+const skeletonVariantKeys = Object.keys(skeletonVariantMap)
+
+export const skeleton = /* @__PURE__ */ Object.assign(memo(skeletonFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'skeleton',
+  __getCompoundVariantCss__: skeletonFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: skeletonVariantKeys,
+  variantMap: skeletonVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, skeletonVariantKeys)
+  },
+  getVariantProps: skeletonFn.getVariantProps,
+})

package/dist/recipes/slider.d.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SliderVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+/**
+ * @default "outline"
+ */
+variant: "outline"
+/**
+ * @default "horizontal"
+ */
+orientation: "vertical" | "horizontal"
+}
+
+type SliderVariantMap = {
+  [key in keyof SliderVariant]: Array<SliderVariant[key]>
+}
+
+type SliderSlot = "root" | "label" | "thumb" | "valueText" | "track" | "range" | "control" | "markerGroup" | "marker" | "draggingIndicator" | "markerIndicator"
+
+export type SliderVariantProps = {
+  [key in keyof SliderVariant]?: ConditionalValue<SliderVariant[key]> | undefined
+}
+
+export interface SliderRecipe {
+  __slot: SliderSlot
+  __type: SliderVariantProps
+  (props?: SliderVariantProps): Pretty<Record<SliderSlot, string>>
+  raw: (props?: SliderVariantProps) => SliderVariantProps
+  variantMap: SliderVariantMap
+  variantKeys: Array<keyof SliderVariant>
+  splitVariantProps<Props extends SliderVariantProps>(props: Props): [SliderVariantProps, Pretty<DistributiveOmit<Props, keyof SliderVariantProps>>]
+  getVariantProps: (props?: SliderVariantProps) => SliderVariantProps
+}
+
+
+export declare const slider: SliderRecipe

package/dist/recipes/slider.mjs

@@ -0,0 +1,94 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const sliderDefaultVariants = {
+  "size": "md",
+  "variant": "outline",
+  "orientation": "horizontal"
+}
+const sliderCompoundVariants = []
+
+const sliderSlotNames = [
+  [
+    "root",
+    "slider__root"
+  ],
+  [
+    "label",
+    "slider__label"
+  ],
+  [
+    "thumb",
+    "slider__thumb"
+  ],
+  [
+    "valueText",
+    "slider__valueText"
+  ],
+  [
+    "track",
+    "slider__track"
+  ],
+  [
+    "range",
+    "slider__range"
+  ],
+  [
+    "control",
+    "slider__control"
+  ],
+  [
+    "markerGroup",
+    "slider__markerGroup"
+  ],
+  [
+    "marker",
+    "slider__marker"
+  ],
+  [
+    "draggingIndicator",
+    "slider__draggingIndicator"
+  ],
+  [
+    "markerIndicator",
+    "slider__markerIndicator"
+  ]
+]
+const sliderSlotFns = /* @__PURE__ */ sliderSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sliderDefaultVariants, getSlotCompoundVariant(sliderCompoundVariants, slotName))])
+
+const sliderFn = memo((props = {}) => {
+  return Object.fromEntries(sliderSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const sliderVariantKeys = [
+  "size",
+  "variant",
+  "orientation"
+]
+const getVariantProps = (variants) => ({ ...sliderDefaultVariants, ...compact(variants) })
+
+export const slider = /* @__PURE__ */ Object.assign(sliderFn, {
+  __recipe__: false,
+  __name__: 'slider',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: sliderVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "variant": [
+    "outline"
+  ],
+  "orientation": [
+    "vertical",
+    "horizontal"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, sliderVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/spinner.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SpinnerVariant {
+  /**
+ * @default "md"
+ */
+size: "inherit" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type SpinnerVariantMap = {
+  [key in keyof SpinnerVariant]: Array<SpinnerVariant[key]>
+}
+
+
+
+export type SpinnerVariantProps = {
+  [key in keyof SpinnerVariant]?: ConditionalValue<SpinnerVariant[key]> | undefined
+}
+
+export interface SpinnerRecipe {
+  
+  __type: SpinnerVariantProps
+  (props?: SpinnerVariantProps): string
+  raw: (props?: SpinnerVariantProps) => SpinnerVariantProps
+  variantMap: SpinnerVariantMap
+  variantKeys: Array<keyof SpinnerVariant>
+  splitVariantProps<Props extends SpinnerVariantProps>(props: Props): [SpinnerVariantProps, Pretty<DistributiveOmit<Props, keyof SpinnerVariantProps>>]
+  getVariantProps: (props?: SpinnerVariantProps) => SpinnerVariantProps
+}
+
+
+export declare const spinner: SpinnerRecipe