@pyck/styled-system 0.0.1

package/dist/recipes/data-list.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataListVariant {
+  
+}
+
+type DataListVariantMap = {
+  [key in keyof DataListVariant]: Array<DataListVariant[key]>
+}
+
+type DataListSlot = "root" | "label" | "list" | "item" | "term" | "value"
+
+export type DataListVariantProps = {
+  [key in keyof DataListVariant]?: ConditionalValue<DataListVariant[key]> | undefined
+}
+
+export interface DataListRecipe {
+  __slot: DataListSlot
+  __type: DataListVariantProps
+  (props?: DataListVariantProps): Pretty<Record<DataListSlot, string>>
+  raw: (props?: DataListVariantProps) => DataListVariantProps
+  variantMap: DataListVariantMap
+  variantKeys: Array<keyof DataListVariant>
+  splitVariantProps<Props extends DataListVariantProps>(props: Props): [DataListVariantProps, Pretty<DistributiveOmit<Props, keyof DataListVariantProps>>]
+  getVariantProps: (props?: DataListVariantProps) => DataListVariantProps
+}
+
+
+export declare const dataList: DataListRecipe

package/dist/recipes/data-list.mjs

@@ -0,0 +1,53 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dataListDefaultVariants = {}
+const dataListCompoundVariants = []
+
+const dataListSlotNames = [
+  [
+    "root",
+    "data-list__root"
+  ],
+  [
+    "label",
+    "data-list__label"
+  ],
+  [
+    "list",
+    "data-list__list"
+  ],
+  [
+    "item",
+    "data-list__item"
+  ],
+  [
+    "term",
+    "data-list__term"
+  ],
+  [
+    "value",
+    "data-list__value"
+  ]
+]
+const dataListSlotFns = /* @__PURE__ */ dataListSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataListDefaultVariants, getSlotCompoundVariant(dataListCompoundVariants, slotName))])
+
+const dataListFn = memo((props = {}) => {
+  return Object.fromEntries(dataListSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const dataListVariantKeys = []
+const getVariantProps = (variants) => ({ ...dataListDefaultVariants, ...compact(variants) })
+
+export const dataList = /* @__PURE__ */ Object.assign(dataListFn, {
+  __recipe__: false,
+  __name__: 'dataList',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: dataListVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dataListVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/date-picker.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DatePickerVariant {
+  
+}
+
+type DatePickerVariantMap = {
+  [key in keyof DatePickerVariant]: Array<DatePickerVariant[key]>
+}
+
+type DatePickerSlot = "clearTrigger" | "content" | "control" | "input" | "label" | "monthSelect" | "nextTrigger" | "positioner" | "presetTrigger" | "prevTrigger" | "rangeText" | "root" | "table" | "tableBody" | "tableCell" | "tableCellTrigger" | "tableHead" | "tableHeader" | "tableRow" | "trigger" | "view" | "viewControl" | "viewTrigger" | "yearSelect" | "view" | "valueText"
+
+export type DatePickerVariantProps = {
+  [key in keyof DatePickerVariant]?: ConditionalValue<DatePickerVariant[key]> | undefined
+}
+
+export interface DatePickerRecipe {
+  __slot: DatePickerSlot
+  __type: DatePickerVariantProps
+  (props?: DatePickerVariantProps): Pretty<Record<DatePickerSlot, string>>
+  raw: (props?: DatePickerVariantProps) => DatePickerVariantProps
+  variantMap: DatePickerVariantMap
+  variantKeys: Array<keyof DatePickerVariant>
+  splitVariantProps<Props extends DatePickerVariantProps>(props: Props): [DatePickerVariantProps, Pretty<DistributiveOmit<Props, keyof DatePickerVariantProps>>]
+  getVariantProps: (props?: DatePickerVariantProps) => DatePickerVariantProps
+}
+
+
+export declare const datePicker: DatePickerRecipe

package/dist/recipes/date-picker.mjs

@@ -0,0 +1,133 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const datePickerDefaultVariants = {}
+const datePickerCompoundVariants = []
+
+const datePickerSlotNames = [
+  [
+    "clearTrigger",
+    "date-picker__clearTrigger"
+  ],
+  [
+    "content",
+    "date-picker__content"
+  ],
+  [
+    "control",
+    "date-picker__control"
+  ],
+  [
+    "input",
+    "date-picker__input"
+  ],
+  [
+    "label",
+    "date-picker__label"
+  ],
+  [
+    "monthSelect",
+    "date-picker__monthSelect"
+  ],
+  [
+    "nextTrigger",
+    "date-picker__nextTrigger"
+  ],
+  [
+    "positioner",
+    "date-picker__positioner"
+  ],
+  [
+    "presetTrigger",
+    "date-picker__presetTrigger"
+  ],
+  [
+    "prevTrigger",
+    "date-picker__prevTrigger"
+  ],
+  [
+    "rangeText",
+    "date-picker__rangeText"
+  ],
+  [
+    "root",
+    "date-picker__root"
+  ],
+  [
+    "table",
+    "date-picker__table"
+  ],
+  [
+    "tableBody",
+    "date-picker__tableBody"
+  ],
+  [
+    "tableCell",
+    "date-picker__tableCell"
+  ],
+  [
+    "tableCellTrigger",
+    "date-picker__tableCellTrigger"
+  ],
+  [
+    "tableHead",
+    "date-picker__tableHead"
+  ],
+  [
+    "tableHeader",
+    "date-picker__tableHeader"
+  ],
+  [
+    "tableRow",
+    "date-picker__tableRow"
+  ],
+  [
+    "trigger",
+    "date-picker__trigger"
+  ],
+  [
+    "view",
+    "date-picker__view"
+  ],
+  [
+    "viewControl",
+    "date-picker__viewControl"
+  ],
+  [
+    "viewTrigger",
+    "date-picker__viewTrigger"
+  ],
+  [
+    "yearSelect",
+    "date-picker__yearSelect"
+  ],
+  [
+    "view",
+    "date-picker__view"
+  ],
+  [
+    "valueText",
+    "date-picker__valueText"
+  ]
+]
+const datePickerSlotFns = /* @__PURE__ */ datePickerSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, datePickerDefaultVariants, getSlotCompoundVariant(datePickerCompoundVariants, slotName))])
+
+const datePickerFn = memo((props = {}) => {
+  return Object.fromEntries(datePickerSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const datePickerVariantKeys = []
+const getVariantProps = (variants) => ({ ...datePickerDefaultVariants, ...compact(variants) })
+
+export const datePicker = /* @__PURE__ */ Object.assign(datePickerFn, {
+  __recipe__: false,
+  __name__: 'datePicker',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: datePickerVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, datePickerVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/dialog.d.ts

@@ -0,0 +1,46 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DialogVariant {
+  /**
+ * @default "scale"
+ */
+motionPreset: "scale" | "slide-in-bottom" | "slide-in-top" | "slide-in-left" | "slide-in-right" | "none"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "cover" | "full"
+/**
+ * @default "center"
+ */
+placement: "center" | "top" | "bottom"
+/**
+ * @default "outside"
+ */
+scrollBehavior: "inside" | "outside"
+}
+
+type DialogVariantMap = {
+  [key in keyof DialogVariant]: Array<DialogVariant[key]>
+}
+
+type DialogSlot = "trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger" | "header" | "body" | "footer"
+
+export type DialogVariantProps = {
+  [key in keyof DialogVariant]?: ConditionalValue<DialogVariant[key]> | undefined
+}
+
+export interface DialogRecipe {
+  __slot: DialogSlot
+  __type: DialogVariantProps
+  (props?: DialogVariantProps): Pretty<Record<DialogSlot, string>>
+  raw: (props?: DialogVariantProps) => DialogVariantProps
+  variantMap: DialogVariantMap
+  variantKeys: Array<keyof DialogVariant>
+  splitVariantProps<Props extends DialogVariantProps>(props: Props): [DialogVariantProps, Pretty<DistributiveOmit<Props, keyof DialogVariantProps>>]
+  getVariantProps: (props?: DialogVariantProps) => DialogVariantProps
+}
+
+
+export declare const dialog: DialogRecipe

package/dist/recipes/dialog.mjs

@@ -0,0 +1,106 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dialogDefaultVariants = {
+  "size": "md",
+  "scrollBehavior": "outside",
+  "placement": "center",
+  "motionPreset": "scale"
+}
+const dialogCompoundVariants = []
+
+const dialogSlotNames = [
+  [
+    "trigger",
+    "dialog__trigger"
+  ],
+  [
+    "backdrop",
+    "dialog__backdrop"
+  ],
+  [
+    "positioner",
+    "dialog__positioner"
+  ],
+  [
+    "content",
+    "dialog__content"
+  ],
+  [
+    "title",
+    "dialog__title"
+  ],
+  [
+    "description",
+    "dialog__description"
+  ],
+  [
+    "closeTrigger",
+    "dialog__closeTrigger"
+  ],
+  [
+    "header",
+    "dialog__header"
+  ],
+  [
+    "body",
+    "dialog__body"
+  ],
+  [
+    "footer",
+    "dialog__footer"
+  ]
+]
+const dialogSlotFns = /* @__PURE__ */ dialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dialogDefaultVariants, getSlotCompoundVariant(dialogCompoundVariants, slotName))])
+
+const dialogFn = memo((props = {}) => {
+  return Object.fromEntries(dialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const dialogVariantKeys = [
+  "motionPreset",
+  "size",
+  "placement",
+  "scrollBehavior"
+]
+const getVariantProps = (variants) => ({ ...dialogDefaultVariants, ...compact(variants) })
+
+export const dialog = /* @__PURE__ */ Object.assign(dialogFn, {
+  __recipe__: false,
+  __name__: 'dialog',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: dialogVariantKeys,
+  variantMap: {
+  "motionPreset": [
+    "scale",
+    "slide-in-bottom",
+    "slide-in-top",
+    "slide-in-left",
+    "slide-in-right",
+    "none"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "cover",
+    "full"
+  ],
+  "placement": [
+    "center",
+    "top",
+    "bottom"
+  ],
+  "scrollBehavior": [
+    "inside",
+    "outside"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, dialogVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/drawer.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DrawerVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "full"
+/**
+ * @default "end"
+ */
+placement: "start" | "end" | "top" | "bottom"
+}
+
+type DrawerVariantMap = {
+  [key in keyof DrawerVariant]: Array<DrawerVariant[key]>
+}
+
+type DrawerSlot = "trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger" | "header" | "body" | "footer"
+
+export type DrawerVariantProps = {
+  [key in keyof DrawerVariant]?: ConditionalValue<DrawerVariant[key]> | undefined
+}
+
+export interface DrawerRecipe {
+  __slot: DrawerSlot
+  __type: DrawerVariantProps
+  (props?: DrawerVariantProps): Pretty<Record<DrawerSlot, string>>
+  raw: (props?: DrawerVariantProps) => DrawerVariantProps
+  variantMap: DrawerVariantMap
+  variantKeys: Array<keyof DrawerVariant>
+  splitVariantProps<Props extends DrawerVariantProps>(props: Props): [DrawerVariantProps, Pretty<DistributiveOmit<Props, keyof DrawerVariantProps>>]
+  getVariantProps: (props?: DrawerVariantProps) => DrawerVariantProps
+}
+
+
+export declare const drawer: DrawerRecipe

package/dist/recipes/drawer.mjs

@@ -0,0 +1,90 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const drawerDefaultVariants = {
+  "placement": "end",
+  "size": "md"
+}
+const drawerCompoundVariants = []
+
+const drawerSlotNames = [
+  [
+    "trigger",
+    "drawer__trigger"
+  ],
+  [
+    "backdrop",
+    "drawer__backdrop"
+  ],
+  [
+    "positioner",
+    "drawer__positioner"
+  ],
+  [
+    "content",
+    "drawer__content"
+  ],
+  [
+    "title",
+    "drawer__title"
+  ],
+  [
+    "description",
+    "drawer__description"
+  ],
+  [
+    "closeTrigger",
+    "drawer__closeTrigger"
+  ],
+  [
+    "header",
+    "drawer__header"
+  ],
+  [
+    "body",
+    "drawer__body"
+  ],
+  [
+    "footer",
+    "drawer__footer"
+  ]
+]
+const drawerSlotFns = /* @__PURE__ */ drawerSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, drawerDefaultVariants, getSlotCompoundVariant(drawerCompoundVariants, slotName))])
+
+const drawerFn = memo((props = {}) => {
+  return Object.fromEntries(drawerSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const drawerVariantKeys = [
+  "size",
+  "placement"
+]
+const getVariantProps = (variants) => ({ ...drawerDefaultVariants, ...compact(variants) })
+
+export const drawer = /* @__PURE__ */ Object.assign(drawerFn, {
+  __recipe__: false,
+  __name__: 'drawer',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: drawerVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "full"
+  ],
+  "placement": [
+    "start",
+    "end",
+    "top",
+    "bottom"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, drawerVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/drilldown-menu.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DrilldownMenuVariant {
+  
+}
+
+type DrilldownMenuVariantMap = {
+  [key in keyof DrilldownMenuVariant]: Array<DrilldownMenuVariant[key]>
+}
+
+type DrilldownMenuSlot = "root" | "list" | "item" | "trigger" | "viewport" | "content"
+
+export type DrilldownMenuVariantProps = {
+  [key in keyof DrilldownMenuVariant]?: ConditionalValue<DrilldownMenuVariant[key]> | undefined
+}
+
+export interface DrilldownMenuRecipe {
+  __slot: DrilldownMenuSlot
+  __type: DrilldownMenuVariantProps
+  (props?: DrilldownMenuVariantProps): Pretty<Record<DrilldownMenuSlot, string>>
+  raw: (props?: DrilldownMenuVariantProps) => DrilldownMenuVariantProps
+  variantMap: DrilldownMenuVariantMap
+  variantKeys: Array<keyof DrilldownMenuVariant>
+  splitVariantProps<Props extends DrilldownMenuVariantProps>(props: Props): [DrilldownMenuVariantProps, Pretty<DistributiveOmit<Props, keyof DrilldownMenuVariantProps>>]
+  getVariantProps: (props?: DrilldownMenuVariantProps) => DrilldownMenuVariantProps
+}
+
+
+export declare const drilldownMenu: DrilldownMenuRecipe

package/dist/recipes/drilldown-menu.mjs

@@ -0,0 +1,53 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const drilldownMenuDefaultVariants = {}
+const drilldownMenuCompoundVariants = []
+
+const drilldownMenuSlotNames = [
+  [
+    "root",
+    "drilldown-menu__root"
+  ],
+  [
+    "list",
+    "drilldown-menu__list"
+  ],
+  [
+    "item",
+    "drilldown-menu__item"
+  ],
+  [
+    "trigger",
+    "drilldown-menu__trigger"
+  ],
+  [
+    "viewport",
+    "drilldown-menu__viewport"
+  ],
+  [
+    "content",
+    "drilldown-menu__content"
+  ]
+]
+const drilldownMenuSlotFns = /* @__PURE__ */ drilldownMenuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, drilldownMenuDefaultVariants, getSlotCompoundVariant(drilldownMenuCompoundVariants, slotName))])
+
+const drilldownMenuFn = memo((props = {}) => {
+  return Object.fromEntries(drilldownMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const drilldownMenuVariantKeys = []
+const getVariantProps = (variants) => ({ ...drilldownMenuDefaultVariants, ...compact(variants) })
+
+export const drilldownMenu = /* @__PURE__ */ Object.assign(drilldownMenuFn, {
+  __recipe__: false,
+  __name__: 'drilldownMenu',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: drilldownMenuVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, drilldownMenuVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/field.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FieldVariant {
+  
+}
+
+type FieldVariantMap = {
+  [key in keyof FieldVariant]: Array<FieldVariant[key]>
+}
+
+type FieldSlot = "root" | "errorText" | "helperText" | "input" | "label" | "select" | "textarea" | "requiredIndicator"
+
+export type FieldVariantProps = {
+  [key in keyof FieldVariant]?: ConditionalValue<FieldVariant[key]> | undefined
+}
+
+export interface FieldRecipe {
+  __slot: FieldSlot
+  __type: FieldVariantProps
+  (props?: FieldVariantProps): Pretty<Record<FieldSlot, string>>
+  raw: (props?: FieldVariantProps) => FieldVariantProps
+  variantMap: FieldVariantMap
+  variantKeys: Array<keyof FieldVariant>
+  splitVariantProps<Props extends FieldVariantProps>(props: Props): [FieldVariantProps, Pretty<DistributiveOmit<Props, keyof FieldVariantProps>>]
+  getVariantProps: (props?: FieldVariantProps) => FieldVariantProps
+}
+
+
+export declare const field: FieldRecipe