@pyck/styled-system 0.0.1

package/dist/recipes/index.mjs

@@ -0,0 +1,57 @@
+export * from './absolute-center.mjs';
+export * from './badge.mjs';
+export * from './button.mjs';
+export * from './checkmark.mjs';
+export * from './form.mjs';
+export * from './group.mjs';
+export * from './heading.mjs';
+export * from './icon.mjs';
+export * from './input.mjs';
+export * from './input-addon.mjs';
+export * from './mark.mjs';
+export * from './kbd.mjs';
+export * from './link.mjs';
+export * from './skeleton.mjs';
+export * from './spinner.mjs';
+export * from './text.mjs';
+export * from './textarea.mjs';
+export * from './action-bar.mjs';
+export * from './avatar.mjs';
+export * from './breadcrumb.mjs';
+export * from './card.mjs';
+export * from './carousel.mjs';
+export * from './checkbox.mjs';
+export * from './clipboard.mjs';
+export * from './collapsible.mjs';
+export * from './combobox.mjs';
+export * from './data-list.mjs';
+export * from './date-picker.mjs';
+export * from './dialog.mjs';
+export * from './drawer.mjs';
+export * from './drilldown-menu.mjs';
+export * from './field.mjs';
+export * from './fieldset.mjs';
+export * from './floating-panel.mjs';
+export * from './input-group.mjs';
+export * from './menu.mjs';
+export * from './number-input.mjs';
+export * from './pagination.mjs';
+export * from './popover.mjs';
+export * from './progress.mjs';
+export * from './progress-circle.mjs';
+export * from './radio-card-group.mjs';
+export * from './radio-group.mjs';
+export * from './scroll-area.mjs';
+export * from './segment-group.mjs';
+export * from './select.mjs';
+export * from './slider.mjs';
+export * from './stat.mjs';
+export * from './steps.mjs';
+export * from './switch-recipe.mjs';
+export * from './table.mjs';
+export * from './tabs.mjs';
+export * from './tags-input.mjs';
+export * from './toast.mjs';
+export * from './toggle-group.mjs';
+export * from './tooltip.mjs';
+export * from './tree-view.mjs';

package/dist/recipes/input-addon.d.ts

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

package/dist/recipes/input-addon.mjs

@@ -0,0 +1,39 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const inputAddonFn = /* @__PURE__ */ createRecipe('input-addon', {
+  "size": "md",
+  "variant": "outline"
+}, [])
+
+const inputAddonVariantMap = {
+  "variant": [
+    "outline",
+    "surface"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+}
+
+const inputAddonVariantKeys = Object.keys(inputAddonVariantMap)
+
+export const inputAddon = /* @__PURE__ */ Object.assign(memo(inputAddonFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'inputAddon',
+  __getCompoundVariantCss__: inputAddonFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: inputAddonVariantKeys,
+  variantMap: inputAddonVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, inputAddonVariantKeys)
+  },
+  getVariantProps: inputAddonFn.getVariantProps,
+})

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

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputGroupVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+}
+
+type InputGroupVariantMap = {
+  [key in keyof InputGroupVariant]: Array<InputGroupVariant[key]>
+}
+
+type InputGroupSlot = "root" | "element"
+
+export type InputGroupVariantProps = {
+  [key in keyof InputGroupVariant]?: ConditionalValue<InputGroupVariant[key]> | undefined
+}
+
+export interface InputGroupRecipe {
+  __slot: InputGroupSlot
+  __type: InputGroupVariantProps
+  (props?: InputGroupVariantProps): Pretty<Record<InputGroupSlot, string>>
+  raw: (props?: InputGroupVariantProps) => InputGroupVariantProps
+  variantMap: InputGroupVariantMap
+  variantKeys: Array<keyof InputGroupVariant>
+  splitVariantProps<Props extends InputGroupVariantProps>(props: Props): [InputGroupVariantProps, Pretty<DistributiveOmit<Props, keyof InputGroupVariantProps>>]
+  getVariantProps: (props?: InputGroupVariantProps) => InputGroupVariantProps
+}
+
+
+export declare const inputGroup: InputGroupRecipe

package/dist/recipes/input-group.mjs

@@ -0,0 +1,49 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const inputGroupDefaultVariants = {
+  "size": "md"
+}
+const inputGroupCompoundVariants = []
+
+const inputGroupSlotNames = [
+  [
+    "root",
+    "input-group__root"
+  ],
+  [
+    "element",
+    "input-group__element"
+  ]
+]
+const inputGroupSlotFns = /* @__PURE__ */ inputGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, inputGroupDefaultVariants, getSlotCompoundVariant(inputGroupCompoundVariants, slotName))])
+
+const inputGroupFn = memo((props = {}) => {
+  return Object.fromEntries(inputGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const inputGroupVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...inputGroupDefaultVariants, ...compact(variants) })
+
+export const inputGroup = /* @__PURE__ */ Object.assign(inputGroupFn, {
+  __recipe__: false,
+  __name__: 'inputGroup',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: inputGroupVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, inputGroupVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/input.d.ts

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

package/dist/recipes/input.mjs

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

package/dist/recipes/kbd.d.ts

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

package/dist/recipes/kbd.mjs

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

package/dist/recipes/link.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface LinkVariant {
+  /**
+ * @default "plain"
+ */
+variant: "plain"
+}
+
+type LinkVariantMap = {
+  [key in keyof LinkVariant]: Array<LinkVariant[key]>
+}
+
+
+
+export type LinkVariantProps = {
+  [key in keyof LinkVariant]?: ConditionalValue<LinkVariant[key]> | undefined
+}
+
+export interface LinkRecipe {
+  
+  __type: LinkVariantProps
+  (props?: LinkVariantProps): string
+  raw: (props?: LinkVariantProps) => LinkVariantProps
+  variantMap: LinkVariantMap
+  variantKeys: Array<keyof LinkVariant>
+  splitVariantProps<Props extends LinkVariantProps>(props: Props): [LinkVariantProps, Pretty<DistributiveOmit<Props, keyof LinkVariantProps>>]
+  getVariantProps: (props?: LinkVariantProps) => LinkVariantProps
+}
+
+
+export declare const link: LinkRecipe

package/dist/recipes/link.mjs

@@ -0,0 +1,30 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const linkFn = /* @__PURE__ */ createRecipe('link', {
+  "variant": "plain"
+}, [])
+
+const linkVariantMap = {
+  "variant": [
+    "plain"
+  ]
+}
+
+const linkVariantKeys = Object.keys(linkVariantMap)
+
+export const link = /* @__PURE__ */ Object.assign(memo(linkFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'link',
+  __getCompoundVariantCss__: linkFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: linkVariantKeys,
+  variantMap: linkVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, linkVariantKeys)
+  },
+  getVariantProps: linkFn.getVariantProps,
+})

package/dist/recipes/mark.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MarkVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "subtle" | "text"
+}
+
+type MarkVariantMap = {
+  [key in keyof MarkVariant]: Array<MarkVariant[key]>
+}
+
+
+
+export type MarkVariantProps = {
+  [key in keyof MarkVariant]?: ConditionalValue<MarkVariant[key]> | undefined
+}
+
+export interface MarkRecipe {
+  
+  __type: MarkVariantProps
+  (props?: MarkVariantProps): string
+  raw: (props?: MarkVariantProps) => MarkVariantProps
+  variantMap: MarkVariantMap
+  variantKeys: Array<keyof MarkVariant>
+  splitVariantProps<Props extends MarkVariantProps>(props: Props): [MarkVariantProps, Pretty<DistributiveOmit<Props, keyof MarkVariantProps>>]
+  getVariantProps: (props?: MarkVariantProps) => MarkVariantProps
+}
+
+
+export declare const mark: MarkRecipe

package/dist/recipes/mark.mjs

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const markFn = /* @__PURE__ */ createRecipe('mark', {
+  "variant": "solid"
+}, [])
+
+const markVariantMap = {
+  "variant": [
+    "solid",
+    "subtle",
+    "text"
+  ]
+}
+
+const markVariantKeys = Object.keys(markVariantMap)
+
+export const mark = /* @__PURE__ */ Object.assign(memo(markFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'mark',
+  __getCompoundVariantCss__: markFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: markVariantKeys,
+  variantMap: markVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, markVariantKeys)
+  },
+  getVariantProps: markFn.getVariantProps,
+})

package/dist/recipes/menu.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MenuVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+}
+
+type MenuVariantMap = {
+  [key in keyof MenuVariant]: Array<MenuVariant[key]>
+}
+
+type MenuSlot = "arrow" | "arrowTip" | "content" | "contextTrigger" | "indicator" | "item" | "itemGroup" | "itemGroupLabel" | "itemIndicator" | "itemText" | "positioner" | "separator" | "trigger" | "triggerItem"
+
+export type MenuVariantProps = {
+  [key in keyof MenuVariant]?: ConditionalValue<MenuVariant[key]> | undefined
+}
+
+export interface MenuRecipe {
+  __slot: MenuSlot
+  __type: MenuVariantProps
+  (props?: MenuVariantProps): Pretty<Record<MenuSlot, string>>
+  raw: (props?: MenuVariantProps) => MenuVariantProps
+  variantMap: MenuVariantMap
+  variantKeys: Array<keyof MenuVariant>
+  splitVariantProps<Props extends MenuVariantProps>(props: Props): [MenuVariantProps, Pretty<DistributiveOmit<Props, keyof MenuVariantProps>>]
+  getVariantProps: (props?: MenuVariantProps) => MenuVariantProps
+}
+
+
+export declare const menu: MenuRecipe

package/dist/recipes/menu.mjs

@@ -0,0 +1,97 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const menuDefaultVariants = {
+  "size": "md"
+}
+const menuCompoundVariants = []
+
+const menuSlotNames = [
+  [
+    "arrow",
+    "menu__arrow"
+  ],
+  [
+    "arrowTip",
+    "menu__arrowTip"
+  ],
+  [
+    "content",
+    "menu__content"
+  ],
+  [
+    "contextTrigger",
+    "menu__contextTrigger"
+  ],
+  [
+    "indicator",
+    "menu__indicator"
+  ],
+  [
+    "item",
+    "menu__item"
+  ],
+  [
+    "itemGroup",
+    "menu__itemGroup"
+  ],
+  [
+    "itemGroupLabel",
+    "menu__itemGroupLabel"
+  ],
+  [
+    "itemIndicator",
+    "menu__itemIndicator"
+  ],
+  [
+    "itemText",
+    "menu__itemText"
+  ],
+  [
+    "positioner",
+    "menu__positioner"
+  ],
+  [
+    "separator",
+    "menu__separator"
+  ],
+  [
+    "trigger",
+    "menu__trigger"
+  ],
+  [
+    "triggerItem",
+    "menu__triggerItem"
+  ]
+]
+const menuSlotFns = /* @__PURE__ */ menuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, menuDefaultVariants, getSlotCompoundVariant(menuCompoundVariants, slotName))])
+
+const menuFn = memo((props = {}) => {
+  return Object.fromEntries(menuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const menuVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...menuDefaultVariants, ...compact(variants) })
+
+export const menu = /* @__PURE__ */ Object.assign(menuFn, {
+  __recipe__: false,
+  __name__: 'menu',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: menuVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, menuVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/number-input.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface NumberInputVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg" | "xl"
+/**
+ * @default "surface"
+ */
+variant: "outline" | "surface"
+}
+
+type NumberInputVariantMap = {
+  [key in keyof NumberInputVariant]: Array<NumberInputVariant[key]>
+}
+
+type NumberInputSlot = "root" | "label" | "input" | "control" | "valueText" | "incrementTrigger" | "decrementTrigger" | "scrubber"
+
+export type NumberInputVariantProps = {
+  [key in keyof NumberInputVariant]?: ConditionalValue<NumberInputVariant[key]> | undefined
+}
+
+export interface NumberInputRecipe {
+  __slot: NumberInputSlot
+  __type: NumberInputVariantProps
+  (props?: NumberInputVariantProps): Pretty<Record<NumberInputSlot, string>>
+  raw: (props?: NumberInputVariantProps) => NumberInputVariantProps
+  variantMap: NumberInputVariantMap
+  variantKeys: Array<keyof NumberInputVariant>
+  splitVariantProps<Props extends NumberInputVariantProps>(props: Props): [NumberInputVariantProps, Pretty<DistributiveOmit<Props, keyof NumberInputVariantProps>>]
+  getVariantProps: (props?: NumberInputVariantProps) => NumberInputVariantProps
+}
+
+
+export declare const numberInput: NumberInputRecipe