@pyck/styled-system 0.0.1

package/dist/recipes/field.mjs

@@ -0,0 +1,61 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const fieldDefaultVariants = {}
+const fieldCompoundVariants = []
+
+const fieldSlotNames = [
+  [
+    "root",
+    "field__root"
+  ],
+  [
+    "errorText",
+    "field__errorText"
+  ],
+  [
+    "helperText",
+    "field__helperText"
+  ],
+  [
+    "input",
+    "field__input"
+  ],
+  [
+    "label",
+    "field__label"
+  ],
+  [
+    "select",
+    "field__select"
+  ],
+  [
+    "textarea",
+    "field__textarea"
+  ],
+  [
+    "requiredIndicator",
+    "field__requiredIndicator"
+  ]
+]
+const fieldSlotFns = /* @__PURE__ */ fieldSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, fieldDefaultVariants, getSlotCompoundVariant(fieldCompoundVariants, slotName))])
+
+const fieldFn = memo((props = {}) => {
+  return Object.fromEntries(fieldSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const fieldVariantKeys = []
+const getVariantProps = (variants) => ({ ...fieldDefaultVariants, ...compact(variants) })
+
+export const field = /* @__PURE__ */ Object.assign(fieldFn, {
+  __recipe__: false,
+  __name__: 'field',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: fieldVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, fieldVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/fieldset.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FieldsetVariant {
+  
+}
+
+type FieldsetVariantMap = {
+  [key in keyof FieldsetVariant]: Array<FieldsetVariant[key]>
+}
+
+type FieldsetSlot = "root" | "errorText" | "helperText" | "legend" | "header" | "body" | "footer" | "legend" | "description" | "helperText" | "errorText"
+
+export type FieldsetVariantProps = {
+  [key in keyof FieldsetVariant]?: ConditionalValue<FieldsetVariant[key]> | undefined
+}
+
+export interface FieldsetRecipe {
+  __slot: FieldsetSlot
+  __type: FieldsetVariantProps
+  (props?: FieldsetVariantProps): Pretty<Record<FieldsetSlot, string>>
+  raw: (props?: FieldsetVariantProps) => FieldsetVariantProps
+  variantMap: FieldsetVariantMap
+  variantKeys: Array<keyof FieldsetVariant>
+  splitVariantProps<Props extends FieldsetVariantProps>(props: Props): [FieldsetVariantProps, Pretty<DistributiveOmit<Props, keyof FieldsetVariantProps>>]
+  getVariantProps: (props?: FieldsetVariantProps) => FieldsetVariantProps
+}
+
+
+export declare const fieldset: FieldsetRecipe

package/dist/recipes/fieldset.mjs

@@ -0,0 +1,73 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const fieldsetDefaultVariants = {}
+const fieldsetCompoundVariants = []
+
+const fieldsetSlotNames = [
+  [
+    "root",
+    "fieldset__root"
+  ],
+  [
+    "errorText",
+    "fieldset__errorText"
+  ],
+  [
+    "helperText",
+    "fieldset__helperText"
+  ],
+  [
+    "legend",
+    "fieldset__legend"
+  ],
+  [
+    "header",
+    "fieldset__header"
+  ],
+  [
+    "body",
+    "fieldset__body"
+  ],
+  [
+    "footer",
+    "fieldset__footer"
+  ],
+  [
+    "legend",
+    "fieldset__legend"
+  ],
+  [
+    "description",
+    "fieldset__description"
+  ],
+  [
+    "helperText",
+    "fieldset__helperText"
+  ],
+  [
+    "errorText",
+    "fieldset__errorText"
+  ]
+]
+const fieldsetSlotFns = /* @__PURE__ */ fieldsetSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, fieldsetDefaultVariants, getSlotCompoundVariant(fieldsetCompoundVariants, slotName))])
+
+const fieldsetFn = memo((props = {}) => {
+  return Object.fromEntries(fieldsetSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const fieldsetVariantKeys = []
+const getVariantProps = (variants) => ({ ...fieldsetDefaultVariants, ...compact(variants) })
+
+export const fieldset = /* @__PURE__ */ Object.assign(fieldsetFn, {
+  __recipe__: false,
+  __name__: 'fieldset',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: fieldsetVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, fieldsetVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/floating-panel.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FloatingPanelVariant {
+  
+}
+
+type FloatingPanelVariantMap = {
+  [key in keyof FloatingPanelVariant]: Array<FloatingPanelVariant[key]>
+}
+
+type FloatingPanelSlot = "trigger" | "positioner" | "content" | "header" | "body" | "title" | "resizeTrigger" | "dragTrigger" | "stageTrigger" | "closeTrigger" | "control"
+
+export type FloatingPanelVariantProps = {
+  [key in keyof FloatingPanelVariant]?: ConditionalValue<FloatingPanelVariant[key]> | undefined
+}
+
+export interface FloatingPanelRecipe {
+  __slot: FloatingPanelSlot
+  __type: FloatingPanelVariantProps
+  (props?: FloatingPanelVariantProps): Pretty<Record<FloatingPanelSlot, string>>
+  raw: (props?: FloatingPanelVariantProps) => FloatingPanelVariantProps
+  variantMap: FloatingPanelVariantMap
+  variantKeys: Array<keyof FloatingPanelVariant>
+  splitVariantProps<Props extends FloatingPanelVariantProps>(props: Props): [FloatingPanelVariantProps, Pretty<DistributiveOmit<Props, keyof FloatingPanelVariantProps>>]
+  getVariantProps: (props?: FloatingPanelVariantProps) => FloatingPanelVariantProps
+}
+
+
+export declare const floatingPanel: FloatingPanelRecipe

package/dist/recipes/floating-panel.mjs

@@ -0,0 +1,73 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const floatingPanelDefaultVariants = {}
+const floatingPanelCompoundVariants = []
+
+const floatingPanelSlotNames = [
+  [
+    "trigger",
+    "floating-panel__trigger"
+  ],
+  [
+    "positioner",
+    "floating-panel__positioner"
+  ],
+  [
+    "content",
+    "floating-panel__content"
+  ],
+  [
+    "header",
+    "floating-panel__header"
+  ],
+  [
+    "body",
+    "floating-panel__body"
+  ],
+  [
+    "title",
+    "floating-panel__title"
+  ],
+  [
+    "resizeTrigger",
+    "floating-panel__resizeTrigger"
+  ],
+  [
+    "dragTrigger",
+    "floating-panel__dragTrigger"
+  ],
+  [
+    "stageTrigger",
+    "floating-panel__stageTrigger"
+  ],
+  [
+    "closeTrigger",
+    "floating-panel__closeTrigger"
+  ],
+  [
+    "control",
+    "floating-panel__control"
+  ]
+]
+const floatingPanelSlotFns = /* @__PURE__ */ floatingPanelSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, floatingPanelDefaultVariants, getSlotCompoundVariant(floatingPanelCompoundVariants, slotName))])
+
+const floatingPanelFn = memo((props = {}) => {
+  return Object.fromEntries(floatingPanelSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const floatingPanelVariantKeys = []
+const getVariantProps = (variants) => ({ ...floatingPanelDefaultVariants, ...compact(variants) })
+
+export const floatingPanel = /* @__PURE__ */ Object.assign(floatingPanelFn, {
+  __recipe__: false,
+  __name__: 'floatingPanel',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: floatingPanelVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, floatingPanelVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/form.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FormVariant {
+  
+}
+
+type FormVariantMap = {
+  [key in keyof FormVariant]: Array<FormVariant[key]>
+}
+
+
+
+export type FormVariantProps = {
+  [key in keyof FormVariant]?: ConditionalValue<FormVariant[key]> | undefined
+}
+
+export interface FormRecipe {
+  
+  __type: FormVariantProps
+  (props?: FormVariantProps): string
+  raw: (props?: FormVariantProps) => FormVariantProps
+  variantMap: FormVariantMap
+  variantKeys: Array<keyof FormVariant>
+  splitVariantProps<Props extends FormVariantProps>(props: Props): [FormVariantProps, Pretty<DistributiveOmit<Props, keyof FormVariantProps>>]
+  getVariantProps: (props?: FormVariantProps) => FormVariantProps
+}
+
+
+export declare const form: FormRecipe

package/dist/recipes/form.mjs

@@ -0,0 +1,24 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const formFn = /* @__PURE__ */ createRecipe('form', {}, [])
+
+const formVariantMap = {}
+
+const formVariantKeys = Object.keys(formVariantMap)
+
+export const form = /* @__PURE__ */ Object.assign(memo(formFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'form',
+  __getCompoundVariantCss__: formFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: formVariantKeys,
+  variantMap: formVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, formVariantKeys)
+  },
+  getVariantProps: formFn.getVariantProps,
+})

package/dist/recipes/group.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface GroupVariant {
+  /**
+ * @default "horizontal"
+ */
+orientation: "horizontal" | "vertical"
+attached: boolean
+grow: boolean
+}
+
+type GroupVariantMap = {
+  [key in keyof GroupVariant]: Array<GroupVariant[key]>
+}
+
+
+
+export type GroupVariantProps = {
+  [key in keyof GroupVariant]?: GroupVariant[key] | undefined
+}
+
+export interface GroupRecipe {
+  
+  __type: GroupVariantProps
+  (props?: GroupVariantProps): string
+  raw: (props?: GroupVariantProps) => GroupVariantProps
+  variantMap: GroupVariantMap
+  variantKeys: Array<keyof GroupVariant>
+  splitVariantProps<Props extends GroupVariantProps>(props: Props): [GroupVariantProps, Pretty<DistributiveOmit<Props, keyof GroupVariantProps>>]
+  getVariantProps: (props?: GroupVariantProps) => GroupVariantProps
+}
+
+
+export declare const group: GroupRecipe

package/dist/recipes/group.mjs

@@ -0,0 +1,72 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const groupFn = /* @__PURE__ */ createRecipe('group', {
+  "orientation": "horizontal"
+}, [
+  {
+    "orientation": "horizontal",
+    "attached": true,
+    "css": {
+      "& > *:first-child": {
+        "borderEndRadius": "0",
+        "marginEnd": "-1px"
+      },
+      "& > *:last-child": {
+        "borderStartRadius": "0"
+      },
+      "& > *:not(:first-child):not(:last-child)": {
+        "borderRadius": "0",
+        "marginEnd": "-1px"
+      }
+    }
+  },
+  {
+    "orientation": "vertical",
+    "attached": true,
+    "css": {
+      "& > *:first-child": {
+        "borderBottomRadius": "0",
+        "marginBottom": "-1px"
+      },
+      "& > *:last-child": {
+        "borderTopRadius": "0"
+      },
+      "& > *:not(:first-child):not(:last-child)": {
+        "borderRadius": "0",
+        "marginBottom": "-1px"
+      }
+    }
+  }
+])
+
+const groupVariantMap = {
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ],
+  "attached": [
+    "true"
+  ],
+  "grow": [
+    "true"
+  ]
+}
+
+const groupVariantKeys = Object.keys(groupVariantMap)
+
+export const group = /* @__PURE__ */ Object.assign(memo(groupFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'group',
+  __getCompoundVariantCss__: groupFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: groupVariantKeys,
+  variantMap: groupVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, groupVariantKeys)
+  },
+  getVariantProps: groupFn.getVariantProps,
+})

package/dist/recipes/heading.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface HeadingVariant {
+  size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl"
+}
+
+type HeadingVariantMap = {
+  [key in keyof HeadingVariant]: Array<HeadingVariant[key]>
+}
+
+
+
+export type HeadingVariantProps = {
+  [key in keyof HeadingVariant]?: ConditionalValue<HeadingVariant[key]> | undefined
+}
+
+export interface HeadingRecipe {
+  
+  __type: HeadingVariantProps
+  (props?: HeadingVariantProps): string
+  raw: (props?: HeadingVariantProps) => HeadingVariantProps
+  variantMap: HeadingVariantMap
+  variantKeys: Array<keyof HeadingVariant>
+  splitVariantProps<Props extends HeadingVariantProps>(props: Props): [HeadingVariantProps, Pretty<DistributiveOmit<Props, keyof HeadingVariantProps>>]
+  getVariantProps: (props?: HeadingVariantProps) => HeadingVariantProps
+}
+
+
+export declare const heading: HeadingRecipe

package/dist/recipes/heading.mjs

@@ -0,0 +1,38 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const headingFn = /* @__PURE__ */ createRecipe('heading', {}, [])
+
+const headingVariantMap = {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl",
+    "3xl",
+    "4xl",
+    "5xl",
+    "6xl",
+    "7xl"
+  ]
+}
+
+const headingVariantKeys = Object.keys(headingVariantMap)
+
+export const heading = /* @__PURE__ */ Object.assign(memo(headingFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'heading',
+  __getCompoundVariantCss__: headingFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: headingVariantKeys,
+  variantMap: headingVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, headingVariantKeys)
+  },
+  getVariantProps: headingFn.getVariantProps,
+})

package/dist/recipes/icon.d.ts

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

package/dist/recipes/icon.mjs

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

package/dist/recipes/index.d.ts

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