@discourser/design-system 0.1.6 → 0.2.1

package/styled-system/recipes/accordion.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AccordionVariant {
+  /**
+ * @default "outline"
+ */
+variant: "outline" | "plain"
+/**
+ * @default "md"
+ */
+size: "md"
+}
+
+type AccordionVariantMap = {
+  [key in keyof AccordionVariant]: Array<AccordionVariant[key]>
+}
+
+type AccordionSlot = "root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator" | "itemBody"
+
+export type AccordionVariantProps = {
+  [key in keyof AccordionVariant]?: ConditionalValue<AccordionVariant[key]> | undefined
+}
+
+export interface AccordionRecipe {
+  __slot: AccordionSlot
+  __type: AccordionVariantProps
+  (props?: AccordionVariantProps): Pretty<Record<AccordionSlot, string>>
+  raw: (props?: AccordionVariantProps) => AccordionVariantProps
+  variantMap: AccordionVariantMap
+  variantKeys: Array<keyof AccordionVariant>
+  splitVariantProps<Props extends AccordionVariantProps>(props: Props): [AccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionVariantProps>>]
+  getVariantProps: (props?: AccordionVariantProps) => AccordionVariantProps
+}
+
+
+export declare const accordion: AccordionRecipe

package/styled-system/recipes/accordion.mjs

@@ -0,0 +1,67 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const accordionDefaultVariants = {
+  "size": "md",
+  "variant": "outline"
+}
+const accordionCompoundVariants = []
+
+const accordionSlotNames = [
+  [
+    "root",
+    "accordion__root"
+  ],
+  [
+    "item",
+    "accordion__item"
+  ],
+  [
+    "itemTrigger",
+    "accordion__itemTrigger"
+  ],
+  [
+    "itemContent",
+    "accordion__itemContent"
+  ],
+  [
+    "itemIndicator",
+    "accordion__itemIndicator"
+  ],
+  [
+    "itemBody",
+    "accordion__itemBody"
+  ]
+]
+const accordionSlotFns = /* @__PURE__ */ accordionSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, accordionDefaultVariants, getSlotCompoundVariant(accordionCompoundVariants, slotName))])
+
+const accordionFn = memo((props = {}) => {
+  return Object.fromEntries(accordionSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const accordionVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...accordionDefaultVariants, ...compact(variants) })
+
+export const accordion = /* @__PURE__ */ Object.assign(accordionFn, {
+  __recipe__: false,
+  __name__: 'accordion',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: accordionVariantKeys,
+  variantMap: {
+  "variant": [
+    "outline",
+    "plain"
+  ],
+  "size": [
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, accordionVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/avatar.d.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AvatarVariant {
+  /**
+ * @default "md"
+ */
+size: "full" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+/**
+ * @default "subtle"
+ */
+variant: "solid" | "surface" | "subtle" | "outline"
+/**
+ * @default "full"
+ */
+shape: "square" | "rounded" | "full"
+}
+
+type AvatarVariantMap = {
+  [key in keyof AvatarVariant]: Array<AvatarVariant[key]>
+}
+
+type AvatarSlot = "root" | "image" | "fallback"
+
+export type AvatarVariantProps = {
+  [key in keyof AvatarVariant]?: ConditionalValue<AvatarVariant[key]> | undefined
+}
+
+export interface AvatarRecipe {
+  __slot: AvatarSlot
+  __type: AvatarVariantProps
+  (props?: AvatarVariantProps): Pretty<Record<AvatarSlot, string>>
+  raw: (props?: AvatarVariantProps) => AvatarVariantProps
+  variantMap: AvatarVariantMap
+  variantKeys: Array<keyof AvatarVariant>
+  splitVariantProps<Props extends AvatarVariantProps>(props: Props): [AvatarVariantProps, Pretty<DistributiveOmit<Props, keyof AvatarVariantProps>>]
+  getVariantProps: (props?: AvatarVariantProps) => AvatarVariantProps
+}
+
+
+export declare const avatar: AvatarRecipe

package/styled-system/recipes/avatar.mjs

@@ -0,0 +1,71 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const avatarDefaultVariants = {
+  "size": "md",
+  "shape": "full",
+  "variant": "subtle"
+}
+const avatarCompoundVariants = []
+
+const avatarSlotNames = [
+  [
+    "root",
+    "avatar__root"
+  ],
+  [
+    "image",
+    "avatar__image"
+  ],
+  [
+    "fallback",
+    "avatar__fallback"
+  ]
+]
+const avatarSlotFns = /* @__PURE__ */ avatarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, avatarDefaultVariants, getSlotCompoundVariant(avatarCompoundVariants, slotName))])
+
+const avatarFn = memo((props = {}) => {
+  return Object.fromEntries(avatarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const avatarVariantKeys = [
+  "size",
+  "variant",
+  "shape"
+]
+const getVariantProps = (variants) => ({ ...avatarDefaultVariants, ...compact(variants) })
+
+export const avatar = /* @__PURE__ */ Object.assign(avatarFn, {
+  __recipe__: false,
+  __name__: 'avatar',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: avatarVariantKeys,
+  variantMap: {
+  "size": [
+    "full",
+    "2xs",
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl"
+  ],
+  "variant": [
+    "solid",
+    "surface",
+    "subtle",
+    "outline"
+  ],
+  "shape": [
+    "square",
+    "rounded",
+    "full"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, avatarVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/badge.d.ts

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

package/styled-system/recipes/badge.mjs

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

package/styled-system/recipes/button.d.ts

@@ -4,24 +4,27 @@ import type { DistributiveOmit, Pretty } from '../types/system-types';
 
 interface ButtonVariant {
   /**
- * @default "filled"
+ * @default "solid"
  */
-variant: "filled" | "outlined" | "text" | "elevated" | "tonal"
+variant: "solid" | "surface" | "subtle" | "outline" | "plain"
 /**
  * @default "md"
  */
-size: "sm" | "md" | "lg"
+size: "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
 }
 
 type ButtonVariantMap = {
   [key in keyof ButtonVariant]: Array<ButtonVariant[key]>
 }
 
+
+
 export type ButtonVariantProps = {
   [key in keyof ButtonVariant]?: ConditionalValue<ButtonVariant[key]> | undefined
 }
 
 export interface ButtonRecipe {
+  
   __type: ButtonVariantProps
   (props?: ButtonVariantProps): string
   raw: (props?: ButtonVariantProps) => ButtonVariantProps
@@ -31,9 +34,5 @@ export interface ButtonRecipe {
   getVariantProps: (props?: ButtonVariantProps) => ButtonVariantProps
 }
 
-/**
- * Material Design 3 button component
 
-
- */
 export declare const button: ButtonRecipe

package/styled-system/recipes/button.mjs

@@ -2,22 +2,26 @@ import { memo, splitProps } from '../helpers.mjs';
 import { createRecipe, mergeRecipes } from './create-recipe.mjs';
 
 const buttonFn = /* @__PURE__ */ createRecipe('button', {
-  "variant": "filled",
+  "variant": "solid",
   "size": "md"
 }, [])
 
 const buttonVariantMap = {
   "variant": [
-    "filled",
-    "outlined",
-    "text",
-    "elevated",
-    "tonal"
+    "solid",
+    "surface",
+    "subtle",
+    "outline",
+    "plain"
   ],
   "size": [
+    "2xs",
+    "xs",
     "sm",
     "md",
-    "lg"
+    "lg",
+    "xl",
+    "2xl"
   ]
 }
 

package/styled-system/recipes/card.d.ts

@@ -4,26 +4,25 @@ import type { DistributiveOmit, Pretty } from '../types/system-types';
 
 interface CardVariant {
   /**
- * @default "elevated"
+ * @default "outline"
  */
-variant: "elevated" | "filled" | "outlined"
-/**
- * @default false
- */
-interactive: boolean
+variant: "elevated" | "outline" | "subtle"
 }
 
 type CardVariantMap = {
   [key in keyof CardVariant]: Array<CardVariant[key]>
 }
 
+type CardSlot = "root" | "header" | "body" | "footer" | "title" | "description"
+
 export type CardVariantProps = {
   [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]> | undefined
 }
 
 export interface CardRecipe {
+  __slot: CardSlot
   __type: CardVariantProps
-  (props?: CardVariantProps): string
+  (props?: CardVariantProps): Pretty<Record<CardSlot, string>>
   raw: (props?: CardVariantProps) => CardVariantProps
   variantMap: CardVariantMap
   variantKeys: Array<keyof CardVariant>
@@ -31,9 +30,5 @@ export interface CardRecipe {
   getVariantProps: (props?: CardVariantProps) => CardVariantProps
 }
 
-/**
- * Material Design 3 card component
 
-
- */
 export declare const card: CardRecipe

package/styled-system/recipes/card.mjs

@@ -1,36 +1,63 @@
-import { memo, splitProps } from '../helpers.mjs';
-import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
 
-const cardFn = /* @__PURE__ */ createRecipe('card', {
-  "variant": "elevated",
-  "interactive": false
-}, [])
+const cardDefaultVariants = {
+  "variant": "outline"
+}
+const cardCompoundVariants = []
 
-const cardVariantMap = {
-  "variant": [
-    "elevated",
-    "filled",
-    "outlined"
+const cardSlotNames = [
+  [
+    "root",
+    "card__root"
+  ],
+  [
+    "header",
+    "card__header"
+  ],
+  [
+    "body",
+    "card__body"
+  ],
+  [
+    "footer",
+    "card__footer"
+  ],
+  [
+    "title",
+    "card__title"
   ],
-  "interactive": [
-    "true"
+  [
+    "description",
+    "card__description"
   ]
-}
+]
+const cardSlotFns = /* @__PURE__ */ cardSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, cardDefaultVariants, getSlotCompoundVariant(cardCompoundVariants, slotName))])
+
+const cardFn = memo((props = {}) => {
+  return Object.fromEntries(cardSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
 
-const cardVariantKeys = Object.keys(cardVariantMap)
+const cardVariantKeys = [
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...cardDefaultVariants, ...compact(variants) })
 
-export const card = /* @__PURE__ */ Object.assign(memo(cardFn.recipeFn), {
-  __recipe__: true,
+export const card = /* @__PURE__ */ Object.assign(cardFn, {
+  __recipe__: false,
   __name__: 'card',
-  __getCompoundVariantCss__: cardFn.__getCompoundVariantCss__,
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: cardVariantKeys,
-  variantMap: cardVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
+  variantMap: {
+  "variant": [
+    "elevated",
+    "outline",
+    "subtle"
+  ]
+},
   splitVariantProps(props) {
     return splitProps(props, cardVariantKeys)
   },
-  getVariantProps: cardFn.getVariantProps,
+  getVariantProps
 })

package/styled-system/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: "sm" | "md" | "lg"
+/**
+ * @default "solid"
+ */
+variant: "solid" | "surface" | "subtle" | "outline" | "plain"
+}
+
+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/styled-system/recipes/checkbox.mjs

@@ -0,0 +1,68 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const checkboxDefaultVariants = {
+  "variant": "solid",
+  "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": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "variant": [
+    "solid",
+    "surface",
+    "subtle",
+    "outline",
+    "plain"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, checkboxVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/dialog.d.ts

@@ -6,20 +6,31 @@ interface DialogVariant {
   /**
  * @default "md"
  */
-size: "sm" | "md" | "lg" | "fullscreen"
+size: "xs" | "sm" | "md" | "lg" | "xl" | "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<"backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger", string>>
+  (props?: DialogVariantProps): Pretty<Record<DialogSlot, string>>
   raw: (props?: DialogVariantProps) => DialogVariantProps
   variantMap: DialogVariantMap
   variantKeys: Array<keyof DialogVariant>
@@ -27,9 +38,5 @@ export interface DialogRecipe {
   getVariantProps: (props?: DialogVariantProps) => DialogVariantProps
 }
 
-/**
- * Material Design 3 dialog component
-
 
- */
 export declare const dialog: DialogRecipe