@discourser/design-system 0.1.7 → 0.2.1

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

package/styled-system/recipes/dialog.mjs

@@ -2,11 +2,17 @@ import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mj
 import { createRecipe } from './create-recipe.mjs';
 
 const dialogDefaultVariants = {
-  "size": "md"
+  "size": "md",
+  "scrollBehavior": "outside",
+  "placement": "center"
 }
 const dialogCompoundVariants = []
 
 const dialogSlotNames = [
+  [
+    "trigger",
+    "dialog__trigger"
+  ],
   [
     "backdrop",
     "dialog__backdrop"
@@ -30,6 +36,18 @@ const dialogSlotNames = [
   [
     "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))])
@@ -39,7 +57,9 @@ const dialogFn = memo((props = {}) => {
 })
 
 const dialogVariantKeys = [
-  "size"
+  "size",
+  "placement",
+  "scrollBehavior"
 ]
 const getVariantProps = (variants) => ({ ...dialogDefaultVariants, ...compact(variants) })
 
@@ -47,13 +67,25 @@ export const dialog = /* @__PURE__ */ Object.assign(dialogFn, {
   __recipe__: false,
   __name__: 'dialog',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: dialogVariantKeys,
   variantMap: {
   "size": [
+    "xs",
     "sm",
     "md",
     "lg",
-    "fullscreen"
+    "xl",
+    "full"
+  ],
+  "placement": [
+    "center",
+    "top",
+    "bottom"
+  ],
+  "scrollBehavior": [
+    "inside",
+    "outside"
   ]
 },
   splitVariantProps(props) {

package/styled-system/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 "sm"
+ */
+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/styled-system/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": "sm"
+}
+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/styled-system/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

package/styled-system/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/styled-system/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/styled-system/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/styled-system/recipes/index.d.ts

@@ -1,7 +1,25 @@
 /* eslint-disable */
 export * from './button';
-export * from './card';
-export * from './icon-button';
 export * from './input';
+export * from './group';
+export * from './spinner';
+export * from './absolute-center';
+export * from './badge';
+export * from './skeleton';
+export * from './textarea';
+export * from './field';
+export * from './card';
+export * from './accordion';
+export * from './drawer';
+export * from './tabs';
+export * from './switch-component';
+export * from './checkbox';
+export * from './radio-group';
+export * from './select';
+export * from './slider';
+export * from './avatar';
+export * from './progress';
+export * from './toast';
 export * from './dialog';
-export * from './switch-control';
+export * from './popover';
+export * from './tooltip';

package/styled-system/recipes/index.mjs

@@ -1,6 +1,24 @@
 export * from './button.mjs';
-export * from './card.mjs';
-export * from './icon-button.mjs';
 export * from './input.mjs';
+export * from './group.mjs';
+export * from './spinner.mjs';
+export * from './absolute-center.mjs';
+export * from './badge.mjs';
+export * from './skeleton.mjs';
+export * from './textarea.mjs';
+export * from './field.mjs';
+export * from './card.mjs';
+export * from './accordion.mjs';
+export * from './drawer.mjs';
+export * from './tabs.mjs';
+export * from './switch-component.mjs';
+export * from './checkbox.mjs';
+export * from './radio-group.mjs';
+export * from './select.mjs';
+export * from './slider.mjs';
+export * from './avatar.mjs';
+export * from './progress.mjs';
+export * from './toast.mjs';
 export * from './dialog.mjs';
-export * from './switch-control.mjs';
+export * from './popover.mjs';
+export * from './tooltip.mjs';

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

@@ -4,25 +4,27 @@ import type { DistributiveOmit, Pretty } from '../types/system-types';
 
 interface InputVariant {
   /**
- * @default "outlined"
+ * @default "outline"
  */
-variant: "filled" | "outlined"
+variant: "outline" | "surface" | "subtle" | "flushed"
 /**
  * @default "md"
  */
-size: "sm" | "md"
-state: "error" | "disabled"
+size: "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
 }
 
 type InputVariantMap = {
   [key in keyof InputVariant]: Array<InputVariant[key]>
 }
 
+
+
 export type InputVariantProps = {
   [key in keyof InputVariant]?: ConditionalValue<InputVariant[key]> | undefined
 }
 
 export interface InputRecipe {
+  
   __type: InputVariantProps
   (props?: InputVariantProps): string
   raw: (props?: InputVariantProps) => InputVariantProps
@@ -32,9 +34,5 @@ export interface InputRecipe {
   getVariantProps: (props?: InputVariantProps) => InputVariantProps
 }
 
-/**
- * Material Design 3 text field component
 
-
- */
 export declare const input: InputRecipe

package/styled-system/recipes/input.mjs

@@ -2,22 +2,25 @@ import { memo, splitProps } from '../helpers.mjs';
 import { createRecipe, mergeRecipes } from './create-recipe.mjs';
 
 const inputFn = /* @__PURE__ */ createRecipe('input', {
-  "variant": "outlined",
-  "size": "md"
+  "size": "md",
+  "variant": "outline"
 }, [])
 
 const inputVariantMap = {
   "variant": [
-    "filled",
-    "outlined"
+    "outline",
+    "surface",
+    "subtle",
+    "flushed"
   ],
   "size": [
+    "2xs",
+    "xs",
     "sm",
-    "md"
-  ],
-  "state": [
-    "error",
-    "disabled"
+    "md",
+    "lg",
+    "xl",
+    "2xl"
   ]
 }