@discourser/design-system 0.1.7 → 0.2.1

package/styled-system/recipes/slider.mjs

@@ -0,0 +1,94 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const sliderDefaultVariants = {
+  "size": "md",
+  "variant": "outline",
+  "orientation": "horizontal"
+}
+const sliderCompoundVariants = []
+
+const sliderSlotNames = [
+  [
+    "root",
+    "slider__root"
+  ],
+  [
+    "label",
+    "slider__label"
+  ],
+  [
+    "thumb",
+    "slider__thumb"
+  ],
+  [
+    "valueText",
+    "slider__valueText"
+  ],
+  [
+    "track",
+    "slider__track"
+  ],
+  [
+    "range",
+    "slider__range"
+  ],
+  [
+    "control",
+    "slider__control"
+  ],
+  [
+    "markerGroup",
+    "slider__markerGroup"
+  ],
+  [
+    "marker",
+    "slider__marker"
+  ],
+  [
+    "draggingIndicator",
+    "slider__draggingIndicator"
+  ],
+  [
+    "markerIndicator",
+    "slider__markerIndicator"
+  ]
+]
+const sliderSlotFns = /* @__PURE__ */ sliderSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sliderDefaultVariants, getSlotCompoundVariant(sliderCompoundVariants, slotName))])
+
+const sliderFn = memo((props = {}) => {
+  return Object.fromEntries(sliderSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const sliderVariantKeys = [
+  "size",
+  "variant",
+  "orientation"
+]
+const getVariantProps = (variants) => ({ ...sliderDefaultVariants, ...compact(variants) })
+
+export const slider = /* @__PURE__ */ Object.assign(sliderFn, {
+  __recipe__: false,
+  __name__: 'slider',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: sliderVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "variant": [
+    "outline"
+  ],
+  "orientation": [
+    "vertical",
+    "horizontal"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, sliderVariantKeys)
+  },
+  getVariantProps
+})

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

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

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

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

package/styled-system/recipes/switch-component.mjs

@@ -0,0 +1,65 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const switchComponentDefaultVariants = {
+  "variant": "solid",
+  "size": "md"
+}
+const switchComponentCompoundVariants = []
+
+const switchComponentSlotNames = [
+  [
+    "root",
+    "switchComponent__root"
+  ],
+  [
+    "label",
+    "switchComponent__label"
+  ],
+  [
+    "control",
+    "switchComponent__control"
+  ],
+  [
+    "thumb",
+    "switchComponent__thumb"
+  ],
+  [
+    "indicator",
+    "switchComponent__indicator"
+  ]
+]
+const switchComponentSlotFns = /* @__PURE__ */ switchComponentSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, switchComponentDefaultVariants, getSlotCompoundVariant(switchComponentCompoundVariants, slotName))])
+
+const switchComponentFn = memo((props = {}) => {
+  return Object.fromEntries(switchComponentSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const switchComponentVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...switchComponentDefaultVariants, ...compact(variants) })
+
+export const switchComponent = /* @__PURE__ */ Object.assign(switchComponentFn, {
+  __recipe__: false,
+  __name__: 'switchComponent',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: switchComponentVariantKeys,
+  variantMap: {
+  "variant": [
+    "solid"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, switchComponentVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/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"
+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/styled-system/recipes/tabs.mjs

@@ -0,0 +1,71 @@
+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"
+  ],
+  "fitted": [
+    "true"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tabsVariantKeys)
+  },
+  getVariantProps
+})

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

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

package/styled-system/recipes/textarea.mjs

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

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ToastVariant {
+  
+}
+
+type ToastVariantMap = {
+  [key in keyof ToastVariant]: Array<ToastVariant[key]>
+}
+
+type ToastSlot = "group" | "root" | "title" | "description" | "actionTrigger" | "closeTrigger"
+
+export type ToastVariantProps = {
+  [key in keyof ToastVariant]?: ConditionalValue<ToastVariant[key]> | undefined
+}
+
+export interface ToastRecipe {
+  __slot: ToastSlot
+  __type: ToastVariantProps
+  (props?: ToastVariantProps): Pretty<Record<ToastSlot, string>>
+  raw: (props?: ToastVariantProps) => ToastVariantProps
+  variantMap: ToastVariantMap
+  variantKeys: Array<keyof ToastVariant>
+  splitVariantProps<Props extends ToastVariantProps>(props: Props): [ToastVariantProps, Pretty<DistributiveOmit<Props, keyof ToastVariantProps>>]
+  getVariantProps: (props?: ToastVariantProps) => ToastVariantProps
+}
+
+
+export declare const toast: ToastRecipe

package/styled-system/recipes/toast.mjs

@@ -0,0 +1,53 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toastDefaultVariants = {}
+const toastCompoundVariants = []
+
+const toastSlotNames = [
+  [
+    "group",
+    "toast__group"
+  ],
+  [
+    "root",
+    "toast__root"
+  ],
+  [
+    "title",
+    "toast__title"
+  ],
+  [
+    "description",
+    "toast__description"
+  ],
+  [
+    "actionTrigger",
+    "toast__actionTrigger"
+  ],
+  [
+    "closeTrigger",
+    "toast__closeTrigger"
+  ]
+]
+const toastSlotFns = /* @__PURE__ */ toastSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toastDefaultVariants, getSlotCompoundVariant(toastCompoundVariants, slotName))])
+
+const toastFn = memo((props = {}) => {
+  return Object.fromEntries(toastSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const toastVariantKeys = []
+const getVariantProps = (variants) => ({ ...toastDefaultVariants, ...compact(variants) })
+
+export const toast = /* @__PURE__ */ Object.assign(toastFn, {
+  __recipe__: false,
+  __name__: 'toast',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: toastVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, toastVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TooltipVariant {
+  
+}
+
+type TooltipVariantMap = {
+  [key in keyof TooltipVariant]: Array<TooltipVariant[key]>
+}
+
+type TooltipSlot = "trigger" | "arrow" | "arrowTip" | "positioner" | "content"
+
+export type TooltipVariantProps = {
+  [key in keyof TooltipVariant]?: ConditionalValue<TooltipVariant[key]> | undefined
+}
+
+export interface TooltipRecipe {
+  __slot: TooltipSlot
+  __type: TooltipVariantProps
+  (props?: TooltipVariantProps): Pretty<Record<TooltipSlot, string>>
+  raw: (props?: TooltipVariantProps) => TooltipVariantProps
+  variantMap: TooltipVariantMap
+  variantKeys: Array<keyof TooltipVariant>
+  splitVariantProps<Props extends TooltipVariantProps>(props: Props): [TooltipVariantProps, Pretty<DistributiveOmit<Props, keyof TooltipVariantProps>>]
+  getVariantProps: (props?: TooltipVariantProps) => TooltipVariantProps
+}
+
+
+export declare const tooltip: TooltipRecipe

package/styled-system/recipes/tooltip.mjs

@@ -0,0 +1,49 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tooltipDefaultVariants = {}
+const tooltipCompoundVariants = []
+
+const tooltipSlotNames = [
+  [
+    "trigger",
+    "tooltip__trigger"
+  ],
+  [
+    "arrow",
+    "tooltip__arrow"
+  ],
+  [
+    "arrowTip",
+    "tooltip__arrowTip"
+  ],
+  [
+    "positioner",
+    "tooltip__positioner"
+  ],
+  [
+    "content",
+    "tooltip__content"
+  ]
+]
+const tooltipSlotFns = /* @__PURE__ */ tooltipSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tooltipDefaultVariants, getSlotCompoundVariant(tooltipCompoundVariants, slotName))])
+
+const tooltipFn = memo((props = {}) => {
+  return Object.fromEntries(tooltipSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tooltipVariantKeys = []
+const getVariantProps = (variants) => ({ ...tooltipDefaultVariants, ...compact(variants) })
+
+export const tooltip = /* @__PURE__ */ Object.assign(tooltipFn, {
+  __recipe__: false,
+  __name__: 'tooltip',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tooltipVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tooltipVariantKeys)
+  },
+  getVariantProps
+})