@pyck/styled-system 0.0.1

package/dist/recipes/spinner.mjs

@@ -0,0 +1,36 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const spinnerFn = /* @__PURE__ */ createRecipe('spinner', {
+  "size": "md"
+}, [])
+
+const spinnerVariantMap = {
+  "size": [
+    "inherit",
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl"
+  ]
+}
+
+const spinnerVariantKeys = Object.keys(spinnerVariantMap)
+
+export const spinner = /* @__PURE__ */ Object.assign(memo(spinnerFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'spinner',
+  __getCompoundVariantCss__: spinnerFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: spinnerVariantKeys,
+  variantMap: spinnerVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, spinnerVariantKeys)
+  },
+  getVariantProps: spinnerFn.getVariantProps,
+})

package/dist/recipes/stat.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface StatVariant {
+  
+}
+
+type StatVariantMap = {
+  [key in keyof StatVariant]: Array<StatVariant[key]>
+}
+
+type StatSlot = "root" | "label" | "valueText"
+
+export type StatVariantProps = {
+  [key in keyof StatVariant]?: ConditionalValue<StatVariant[key]> | undefined
+}
+
+export interface StatRecipe {
+  __slot: StatSlot
+  __type: StatVariantProps
+  (props?: StatVariantProps): Pretty<Record<StatSlot, string>>
+  raw: (props?: StatVariantProps) => StatVariantProps
+  variantMap: StatVariantMap
+  variantKeys: Array<keyof StatVariant>
+  splitVariantProps<Props extends StatVariantProps>(props: Props): [StatVariantProps, Pretty<DistributiveOmit<Props, keyof StatVariantProps>>]
+  getVariantProps: (props?: StatVariantProps) => StatVariantProps
+}
+
+
+export declare const stat: StatRecipe

package/dist/recipes/stat.mjs

@@ -0,0 +1,41 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const statDefaultVariants = {}
+const statCompoundVariants = []
+
+const statSlotNames = [
+  [
+    "root",
+    "stat__root"
+  ],
+  [
+    "label",
+    "stat__label"
+  ],
+  [
+    "valueText",
+    "stat__valueText"
+  ]
+]
+const statSlotFns = /* @__PURE__ */ statSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, statDefaultVariants, getSlotCompoundVariant(statCompoundVariants, slotName))])
+
+const statFn = memo((props = {}) => {
+  return Object.fromEntries(statSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const statVariantKeys = []
+const getVariantProps = (variants) => ({ ...statDefaultVariants, ...compact(variants) })
+
+export const stat = /* @__PURE__ */ Object.assign(statFn, {
+  __recipe__: false,
+  __name__: 'stat',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: statVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, statVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/steps.d.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface StepsVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md"
+/**
+ * @default "solid"
+ */
+variant: "solid"
+/**
+ * @default "horizontal"
+ */
+orientation: "horizontal" | "vertical"
+}
+
+type StepsVariantMap = {
+  [key in keyof StepsVariant]: Array<StepsVariant[key]>
+}
+
+type StepsSlot = "root" | "list" | "item" | "trigger" | "indicator" | "separator" | "content" | "nextTrigger" | "prevTrigger" | "progress" | "title" | "description"
+
+export type StepsVariantProps = {
+  [key in keyof StepsVariant]?: ConditionalValue<StepsVariant[key]> | undefined
+}
+
+export interface StepsRecipe {
+  __slot: StepsSlot
+  __type: StepsVariantProps
+  (props?: StepsVariantProps): Pretty<Record<StepsSlot, string>>
+  raw: (props?: StepsVariantProps) => StepsVariantProps
+  variantMap: StepsVariantMap
+  variantKeys: Array<keyof StepsVariant>
+  splitVariantProps<Props extends StepsVariantProps>(props: Props): [StepsVariantProps, Pretty<DistributiveOmit<Props, keyof StepsVariantProps>>]
+  getVariantProps: (props?: StepsVariantProps) => StepsVariantProps
+}
+
+
+export declare const steps: StepsRecipe

package/dist/recipes/steps.mjs

@@ -0,0 +1,97 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const stepsDefaultVariants = {
+  "variant": "solid",
+  "size": "md",
+  "orientation": "horizontal"
+}
+const stepsCompoundVariants = []
+
+const stepsSlotNames = [
+  [
+    "root",
+    "steps__root"
+  ],
+  [
+    "list",
+    "steps__list"
+  ],
+  [
+    "item",
+    "steps__item"
+  ],
+  [
+    "trigger",
+    "steps__trigger"
+  ],
+  [
+    "indicator",
+    "steps__indicator"
+  ],
+  [
+    "separator",
+    "steps__separator"
+  ],
+  [
+    "content",
+    "steps__content"
+  ],
+  [
+    "nextTrigger",
+    "steps__nextTrigger"
+  ],
+  [
+    "prevTrigger",
+    "steps__prevTrigger"
+  ],
+  [
+    "progress",
+    "steps__progress"
+  ],
+  [
+    "title",
+    "steps__title"
+  ],
+  [
+    "description",
+    "steps__description"
+  ]
+]
+const stepsSlotFns = /* @__PURE__ */ stepsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, stepsDefaultVariants, getSlotCompoundVariant(stepsCompoundVariants, slotName))])
+
+const stepsFn = memo((props = {}) => {
+  return Object.fromEntries(stepsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const stepsVariantKeys = [
+  "size",
+  "variant",
+  "orientation"
+]
+const getVariantProps = (variants) => ({ ...stepsDefaultVariants, ...compact(variants) })
+
+export const steps = /* @__PURE__ */ Object.assign(stepsFn, {
+  __recipe__: false,
+  __name__: 'steps',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: stepsVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ],
+  "variant": [
+    "solid"
+  ],
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, stepsVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/switch-recipe.d.ts

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

package/dist/recipes/switch-recipe.mjs

@@ -0,0 +1,65 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const switchRecipeDefaultVariants = {
+  "variant": "solid",
+  "size": "md"
+}
+const switchRecipeCompoundVariants = []
+
+const switchRecipeSlotNames = [
+  [
+    "root",
+    "switch__root"
+  ],
+  [
+    "label",
+    "switch__label"
+  ],
+  [
+    "control",
+    "switch__control"
+  ],
+  [
+    "thumb",
+    "switch__thumb"
+  ],
+  [
+    "indicator",
+    "switch__indicator"
+  ]
+]
+const switchRecipeSlotFns = /* @__PURE__ */ switchRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, switchRecipeDefaultVariants, getSlotCompoundVariant(switchRecipeCompoundVariants, slotName))])
+
+const switchRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(switchRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const switchRecipeVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...switchRecipeDefaultVariants, ...compact(variants) })
+
+export const switchRecipe = /* @__PURE__ */ Object.assign(switchRecipeFn, {
+  __recipe__: false,
+  __name__: 'switchRecipe',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: switchRecipeVariantKeys,
+  variantMap: {
+  "variant": [
+    "solid"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, switchRecipeVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/table.d.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableVariant {
+  /**
+ * @default "plain"
+ */
+variant: "outline" | "plain"
+interactive: boolean
+stickyHeader: boolean
+/**
+ * @default "md"
+ */
+size: "md"
+}
+
+type TableVariantMap = {
+  [key in keyof TableVariant]: Array<TableVariant[key]>
+}
+
+type TableSlot = "root" | "body" | "cell" | "foot" | "head" | "header" | "row" | "caption"
+
+export type TableVariantProps = {
+  [key in keyof TableVariant]?: ConditionalValue<TableVariant[key]> | undefined
+}
+
+export interface TableRecipe {
+  __slot: TableSlot
+  __type: TableVariantProps
+  (props?: TableVariantProps): Pretty<Record<TableSlot, string>>
+  raw: (props?: TableVariantProps) => TableVariantProps
+  variantMap: TableVariantMap
+  variantKeys: Array<keyof TableVariant>
+  splitVariantProps<Props extends TableVariantProps>(props: Props): [TableVariantProps, Pretty<DistributiveOmit<Props, keyof TableVariantProps>>]
+  getVariantProps: (props?: TableVariantProps) => TableVariantProps
+}
+
+
+export declare const table: TableRecipe

package/dist/recipes/table.mjs

@@ -0,0 +1,83 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableDefaultVariants = {
+  "size": "md",
+  "variant": "plain"
+}
+const tableCompoundVariants = []
+
+const tableSlotNames = [
+  [
+    "root",
+    "table__root"
+  ],
+  [
+    "body",
+    "table__body"
+  ],
+  [
+    "cell",
+    "table__cell"
+  ],
+  [
+    "foot",
+    "table__foot"
+  ],
+  [
+    "head",
+    "table__head"
+  ],
+  [
+    "header",
+    "table__header"
+  ],
+  [
+    "row",
+    "table__row"
+  ],
+  [
+    "caption",
+    "table__caption"
+  ]
+]
+const tableSlotFns = /* @__PURE__ */ tableSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableDefaultVariants, getSlotCompoundVariant(tableCompoundVariants, slotName))])
+
+const tableFn = memo((props = {}) => {
+  return Object.fromEntries(tableSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tableVariantKeys = [
+  "variant",
+  "interactive",
+  "stickyHeader",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...tableDefaultVariants, ...compact(variants) })
+
+export const table = /* @__PURE__ */ Object.assign(tableFn, {
+  __recipe__: false,
+  __name__: 'table',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tableVariantKeys,
+  variantMap: {
+  "variant": [
+    "outline",
+    "plain"
+  ],
+  "interactive": [
+    "true"
+  ],
+  "stickyHeader": [
+    "true"
+  ],
+  "size": [
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tableVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/tabs.d.ts

@@ -0,0 +1,39 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TabsVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+/**
+ * @default "line"
+ */
+variant: "line" | "subtle" | "enclosed" | "outline"
+fitted: boolean
+}
+
+type TabsVariantMap = {
+  [key in keyof TabsVariant]: Array<TabsVariant[key]>
+}
+
+type TabsSlot = "root" | "list" | "trigger" | "content" | "indicator"
+
+export type TabsVariantProps = {
+  [key in keyof TabsVariant]?: ConditionalValue<TabsVariant[key]> | undefined
+}
+
+export interface TabsRecipe {
+  __slot: TabsSlot
+  __type: TabsVariantProps
+  (props?: TabsVariantProps): Pretty<Record<TabsSlot, string>>
+  raw: (props?: TabsVariantProps) => TabsVariantProps
+  variantMap: TabsVariantMap
+  variantKeys: Array<keyof TabsVariant>
+  splitVariantProps<Props extends TabsVariantProps>(props: Props): [TabsVariantProps, Pretty<DistributiveOmit<Props, keyof TabsVariantProps>>]
+  getVariantProps: (props?: TabsVariantProps) => TabsVariantProps
+}
+
+
+export declare const tabs: TabsRecipe

package/dist/recipes/tabs.mjs

@@ -0,0 +1,72 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tabsDefaultVariants = {
+  "size": "md",
+  "variant": "line"
+}
+const tabsCompoundVariants = []
+
+const tabsSlotNames = [
+  [
+    "root",
+    "tabs__root"
+  ],
+  [
+    "list",
+    "tabs__list"
+  ],
+  [
+    "trigger",
+    "tabs__trigger"
+  ],
+  [
+    "content",
+    "tabs__content"
+  ],
+  [
+    "indicator",
+    "tabs__indicator"
+  ]
+]
+const tabsSlotFns = /* @__PURE__ */ tabsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tabsDefaultVariants, getSlotCompoundVariant(tabsCompoundVariants, slotName))])
+
+const tabsFn = memo((props = {}) => {
+  return Object.fromEntries(tabsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tabsVariantKeys = [
+  "size",
+  "variant",
+  "fitted"
+]
+const getVariantProps = (variants) => ({ ...tabsDefaultVariants, ...compact(variants) })
+
+export const tabs = /* @__PURE__ */ Object.assign(tabsFn, {
+  __recipe__: false,
+  __name__: 'tabs',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tabsVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ],
+  "variant": [
+    "line",
+    "subtle",
+    "enclosed",
+    "outline"
+  ],
+  "fitted": [
+    "true"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tabsVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TagsInputVariant {
+  /**
+ * @default "surface"
+ */
+variant: "outline" | "surface"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+}
+
+type TagsInputVariantMap = {
+  [key in keyof TagsInputVariant]: Array<TagsInputVariant[key]>
+}
+
+type TagsInputSlot = "root" | "label" | "control" | "input" | "clearTrigger" | "item" | "itemPreview" | "itemInput" | "itemText" | "itemDeleteTrigger"
+
+export type TagsInputVariantProps = {
+  [key in keyof TagsInputVariant]?: ConditionalValue<TagsInputVariant[key]> | undefined
+}
+
+export interface TagsInputRecipe {
+  __slot: TagsInputSlot
+  __type: TagsInputVariantProps
+  (props?: TagsInputVariantProps): Pretty<Record<TagsInputSlot, string>>
+  raw: (props?: TagsInputVariantProps) => TagsInputVariantProps
+  variantMap: TagsInputVariantMap
+  variantKeys: Array<keyof TagsInputVariant>
+  splitVariantProps<Props extends TagsInputVariantProps>(props: Props): [TagsInputVariantProps, Pretty<DistributiveOmit<Props, keyof TagsInputVariantProps>>]
+  getVariantProps: (props?: TagsInputVariantProps) => TagsInputVariantProps
+}
+
+
+export declare const tagsInput: TagsInputRecipe