@pyck/styled-system 0.0.1

package/dist/recipes/carousel.mjs

@@ -0,0 +1,93 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const carouselDefaultVariants = {
+  "size": "md"
+}
+const carouselCompoundVariants = []
+
+const carouselSlotNames = [
+  [
+    "root",
+    "carousel__root"
+  ],
+  [
+    "itemGroup",
+    "carousel__itemGroup"
+  ],
+  [
+    "item",
+    "carousel__item"
+  ],
+  [
+    "control",
+    "carousel__control"
+  ],
+  [
+    "nextTrigger",
+    "carousel__nextTrigger"
+  ],
+  [
+    "prevTrigger",
+    "carousel__prevTrigger"
+  ],
+  [
+    "indicatorGroup",
+    "carousel__indicatorGroup"
+  ],
+  [
+    "indicator",
+    "carousel__indicator"
+  ],
+  [
+    "autoplayTrigger",
+    "carousel__autoplayTrigger"
+  ],
+  [
+    "progressText",
+    "carousel__progressText"
+  ],
+  [
+    "progressText",
+    "carousel__progressText"
+  ],
+  [
+    "autoplayIndicator",
+    "carousel__autoplayIndicator"
+  ],
+  [
+    "image",
+    "carousel__image"
+  ]
+]
+const carouselSlotFns = /* @__PURE__ */ carouselSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, carouselDefaultVariants, getSlotCompoundVariant(carouselCompoundVariants, slotName))])
+
+const carouselFn = memo((props = {}) => {
+  return Object.fromEntries(carouselSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const carouselVariantKeys = [
+  "inline",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...carouselDefaultVariants, ...compact(variants) })
+
+export const carousel = /* @__PURE__ */ Object.assign(carouselFn, {
+  __recipe__: false,
+  __name__: 'carousel',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: carouselVariantKeys,
+  variantMap: {
+  "inline": [
+    "true"
+  ],
+  "size": [
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, carouselVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/checkbox.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CheckboxVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+/**
+ * @default "surface"
+ */
+variant: "solid" | "surface" | "subtle"
+}
+
+type CheckboxVariantMap = {
+  [key in keyof CheckboxVariant]: Array<CheckboxVariant[key]>
+}
+
+type CheckboxSlot = "root" | "label" | "control" | "indicator" | "group"
+
+export type CheckboxVariantProps = {
+  [key in keyof CheckboxVariant]?: ConditionalValue<CheckboxVariant[key]> | undefined
+}
+
+export interface CheckboxRecipe {
+  __slot: CheckboxSlot
+  __type: CheckboxVariantProps
+  (props?: CheckboxVariantProps): Pretty<Record<CheckboxSlot, string>>
+  raw: (props?: CheckboxVariantProps) => CheckboxVariantProps
+  variantMap: CheckboxVariantMap
+  variantKeys: Array<keyof CheckboxVariant>
+  splitVariantProps<Props extends CheckboxVariantProps>(props: Props): [CheckboxVariantProps, Pretty<DistributiveOmit<Props, keyof CheckboxVariantProps>>]
+  getVariantProps: (props?: CheckboxVariantProps) => CheckboxVariantProps
+}
+
+
+export declare const checkbox: CheckboxRecipe

package/dist/recipes/checkbox.mjs

@@ -0,0 +1,67 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const checkboxDefaultVariants = {
+  "variant": "surface",
+  "size": "md"
+}
+const checkboxCompoundVariants = []
+
+const checkboxSlotNames = [
+  [
+    "root",
+    "checkbox__root"
+  ],
+  [
+    "label",
+    "checkbox__label"
+  ],
+  [
+    "control",
+    "checkbox__control"
+  ],
+  [
+    "indicator",
+    "checkbox__indicator"
+  ],
+  [
+    "group",
+    "checkbox__group"
+  ]
+]
+const checkboxSlotFns = /* @__PURE__ */ checkboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, checkboxDefaultVariants, getSlotCompoundVariant(checkboxCompoundVariants, slotName))])
+
+const checkboxFn = memo((props = {}) => {
+  return Object.fromEntries(checkboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const checkboxVariantKeys = [
+  "size",
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...checkboxDefaultVariants, ...compact(variants) })
+
+export const checkbox = /* @__PURE__ */ Object.assign(checkboxFn, {
+  __recipe__: false,
+  __name__: 'checkbox',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: checkboxVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ],
+  "variant": [
+    "solid",
+    "surface",
+    "subtle"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, checkboxVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/checkmark.d.ts

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

package/dist/recipes/checkmark.mjs

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

package/dist/recipes/clipboard.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ClipboardVariant {
+  
+}
+
+type ClipboardVariantMap = {
+  [key in keyof ClipboardVariant]: Array<ClipboardVariant[key]>
+}
+
+type ClipboardSlot = "root" | "control" | "trigger" | "indicator" | "input" | "label"
+
+export type ClipboardVariantProps = {
+  [key in keyof ClipboardVariant]?: ConditionalValue<ClipboardVariant[key]> | undefined
+}
+
+export interface ClipboardRecipe {
+  __slot: ClipboardSlot
+  __type: ClipboardVariantProps
+  (props?: ClipboardVariantProps): Pretty<Record<ClipboardSlot, string>>
+  raw: (props?: ClipboardVariantProps) => ClipboardVariantProps
+  variantMap: ClipboardVariantMap
+  variantKeys: Array<keyof ClipboardVariant>
+  splitVariantProps<Props extends ClipboardVariantProps>(props: Props): [ClipboardVariantProps, Pretty<DistributiveOmit<Props, keyof ClipboardVariantProps>>]
+  getVariantProps: (props?: ClipboardVariantProps) => ClipboardVariantProps
+}
+
+
+export declare const clipboard: ClipboardRecipe

package/dist/recipes/clipboard.mjs

@@ -0,0 +1,53 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const clipboardDefaultVariants = {}
+const clipboardCompoundVariants = []
+
+const clipboardSlotNames = [
+  [
+    "root",
+    "clipboard__root"
+  ],
+  [
+    "control",
+    "clipboard__control"
+  ],
+  [
+    "trigger",
+    "clipboard__trigger"
+  ],
+  [
+    "indicator",
+    "clipboard__indicator"
+  ],
+  [
+    "input",
+    "clipboard__input"
+  ],
+  [
+    "label",
+    "clipboard__label"
+  ]
+]
+const clipboardSlotFns = /* @__PURE__ */ clipboardSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, clipboardDefaultVariants, getSlotCompoundVariant(clipboardCompoundVariants, slotName))])
+
+const clipboardFn = memo((props = {}) => {
+  return Object.fromEntries(clipboardSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const clipboardVariantKeys = []
+const getVariantProps = (variants) => ({ ...clipboardDefaultVariants, ...compact(variants) })
+
+export const clipboard = /* @__PURE__ */ Object.assign(clipboardFn, {
+  __recipe__: false,
+  __name__: 'clipboard',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: clipboardVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, clipboardVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/collapsible.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CollapsibleVariant {
+  /**
+ * @default "vertical"
+ */
+orientation: "vertical" | "horizontal"
+}
+
+type CollapsibleVariantMap = {
+  [key in keyof CollapsibleVariant]: Array<CollapsibleVariant[key]>
+}
+
+type CollapsibleSlot = "root" | "trigger" | "content" | "indicator"
+
+export type CollapsibleVariantProps = {
+  [key in keyof CollapsibleVariant]?: ConditionalValue<CollapsibleVariant[key]> | undefined
+}
+
+export interface CollapsibleRecipe {
+  __slot: CollapsibleSlot
+  __type: CollapsibleVariantProps
+  (props?: CollapsibleVariantProps): Pretty<Record<CollapsibleSlot, string>>
+  raw: (props?: CollapsibleVariantProps) => CollapsibleVariantProps
+  variantMap: CollapsibleVariantMap
+  variantKeys: Array<keyof CollapsibleVariant>
+  splitVariantProps<Props extends CollapsibleVariantProps>(props: Props): [CollapsibleVariantProps, Pretty<DistributiveOmit<Props, keyof CollapsibleVariantProps>>]
+  getVariantProps: (props?: CollapsibleVariantProps) => CollapsibleVariantProps
+}
+
+
+export declare const collapsible: CollapsibleRecipe

package/dist/recipes/collapsible.mjs

@@ -0,0 +1,54 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const collapsibleDefaultVariants = {
+  "orientation": "vertical"
+}
+const collapsibleCompoundVariants = []
+
+const collapsibleSlotNames = [
+  [
+    "root",
+    "collapsible__root"
+  ],
+  [
+    "trigger",
+    "collapsible__trigger"
+  ],
+  [
+    "content",
+    "collapsible__content"
+  ],
+  [
+    "indicator",
+    "collapsible__indicator"
+  ]
+]
+const collapsibleSlotFns = /* @__PURE__ */ collapsibleSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, collapsibleDefaultVariants, getSlotCompoundVariant(collapsibleCompoundVariants, slotName))])
+
+const collapsibleFn = memo((props = {}) => {
+  return Object.fromEntries(collapsibleSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const collapsibleVariantKeys = [
+  "orientation"
+]
+const getVariantProps = (variants) => ({ ...collapsibleDefaultVariants, ...compact(variants) })
+
+export const collapsible = /* @__PURE__ */ Object.assign(collapsibleFn, {
+  __recipe__: false,
+  __name__: 'collapsible',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: collapsibleVariantKeys,
+  variantMap: {
+  "orientation": [
+    "vertical",
+    "horizontal"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, collapsibleVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/combobox.d.ts

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

package/dist/recipes/combobox.mjs

@@ -0,0 +1,112 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const comboboxDefaultVariants = {
+  "size": "md",
+  "variant": "surface"
+}
+const comboboxCompoundVariants = []
+
+const comboboxSlotNames = [
+  [
+    "root",
+    "combobox__root"
+  ],
+  [
+    "clearTrigger",
+    "combobox__clearTrigger"
+  ],
+  [
+    "content",
+    "combobox__content"
+  ],
+  [
+    "control",
+    "combobox__control"
+  ],
+  [
+    "input",
+    "combobox__input"
+  ],
+  [
+    "item",
+    "combobox__item"
+  ],
+  [
+    "itemGroup",
+    "combobox__itemGroup"
+  ],
+  [
+    "itemGroupLabel",
+    "combobox__itemGroupLabel"
+  ],
+  [
+    "itemIndicator",
+    "combobox__itemIndicator"
+  ],
+  [
+    "itemText",
+    "combobox__itemText"
+  ],
+  [
+    "label",
+    "combobox__label"
+  ],
+  [
+    "list",
+    "combobox__list"
+  ],
+  [
+    "positioner",
+    "combobox__positioner"
+  ],
+  [
+    "trigger",
+    "combobox__trigger"
+  ],
+  [
+    "empty",
+    "combobox__empty"
+  ],
+  [
+    "indicatorGroup",
+    "combobox__indicatorGroup"
+  ]
+]
+const comboboxSlotFns = /* @__PURE__ */ comboboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, comboboxDefaultVariants, getSlotCompoundVariant(comboboxCompoundVariants, slotName))])
+
+const comboboxFn = memo((props = {}) => {
+  return Object.fromEntries(comboboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const comboboxVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...comboboxDefaultVariants, ...compact(variants) })
+
+export const combobox = /* @__PURE__ */ Object.assign(comboboxFn, {
+  __recipe__: false,
+  __name__: 'combobox',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: comboboxVariantKeys,
+  variantMap: {
+  "variant": [
+    "outline",
+    "surface",
+    "plain"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, comboboxVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/create-recipe.mjs

@@ -0,0 +1,82 @@
+import { finalizeConditions, sortConditions } from '../css/conditions.mjs';
+import { css } from '../css/css.mjs';
+import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.mjs';
+import { cx } from '../css/cx.mjs';
+import { compact, createCss, splitProps, uniq, withoutSpace } from '../helpers.mjs';
+
+export const createRecipe = (name, defaultVariants, compoundVariants) => {
+ const getVariantProps = (variants) => {
+   return {
+     [name]: '__ignore__',
+     ...defaultVariants,
+     ...compact(variants),
+   };
+ };
+
+  const recipeFn = (variants, withCompoundVariants = true) => {
+   const transform = (prop, value) => {
+     assertCompoundVariant(name, compoundVariants, variants, prop)
+
+      if (value === '__ignore__') {
+        return { className: name }
+      }
+
+      value = withoutSpace(value)
+      return { className: `${name}--${prop}_${value}` }
+   }
+
+   const recipeCss = createCss({
+     
+     conditions: {
+       shift: sortConditions,
+       finalize: finalizeConditions,
+       breakpoints: { keys: ["base","sm","md","lg","xl","2xl"] }
+     },
+     utility: {
+       
+       toHash: (path, hashFn) => hashFn(path.join(":")),
+       transform,
+     }
+   })
+
+   const recipeStyles = getVariantProps(variants)
+
+   if (withCompoundVariants) {
+     const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles)
+     return cx(recipeCss(recipeStyles), css(compoundVariantStyles))
+   }
+
+   return recipeCss(recipeStyles)
+  }
+
+   return {
+     recipeFn,
+     getVariantProps,
+     __getCompoundVariantCss__: (variants) => {
+       return getCompoundVariantCss(compoundVariants, getVariantProps(variants));
+     },
+   }
+}
+
+export const mergeRecipes = (recipeA, recipeB) => {
+ if (recipeA && !recipeB) return recipeA
+ if (!recipeA && recipeB) return recipeB
+
+ const recipeFn = (...args) => cx(recipeA(...args), recipeB(...args))
+ const variantKeys = uniq(recipeA.variantKeys, recipeB.variantKeys)
+ const variantMap = variantKeys.reduce((acc, key) => {
+   acc[key] = uniq(recipeA.variantMap[key], recipeB.variantMap[key])
+   return acc
+ }, {})
+
+ return Object.assign(recipeFn, {
+   __recipe__: true,
+   __name__: `${recipeA.__name__} ${recipeB.__name__}`,
+   raw: (props) => props,
+   variantKeys,
+   variantMap,
+   splitVariantProps(props) {
+     return splitProps(props, variantKeys)
+   },
+ })
+ }