@luxonis/common-fe-components 1.9.5

package/dist/styled-system/patterns/vstack.mjs

@@ -0,0 +1,20 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const vstackConfig = {
+transform(props) {
+  const { justify, gap = "10px", ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: justify,
+    gap,
+    flexDirection: "column",
+    ...rest
+  };
+}}
+
+export const getVstackStyle = (styles = {}) => vstackConfig.transform(styles, { map: mapObject })
+
+export const vstack = (styles) => css(getVstackStyle(styles))
+vstack.raw = getVstackStyle

package/dist/styled-system/patterns/wrap.d.mts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface WrapProperties {
+   gap?: PropertyValue<'gap'>
+	rowGap?: PropertyValue<'gap'>
+	columnGap?: PropertyValue<'gap'>
+	align?: PropertyValue<'alignItems'>
+	justify?: PropertyValue<'justifyContent'>
+}
+
+
+interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+}
+
+
+export declare const wrap: WrapPatternFn;

package/dist/styled-system/patterns/wrap.mjs

@@ -0,0 +1,22 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const wrapConfig = {
+transform(props) {
+  const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "10px", align, justify, ...rest } = props;
+  return {
+    display: "flex",
+    flexWrap: "wrap",
+    alignItems: align,
+    justifyContent: justify,
+    gap,
+    columnGap,
+    rowGap,
+    ...rest
+  };
+}}
+
+export const getWrapStyle = (styles = {}) => wrapConfig.transform(styles, { map: mapObject })
+
+export const wrap = (styles) => css(getWrapStyle(styles))
+wrap.raw = getWrapStyle

package/dist/styled-system/recipes/accordion.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AccordionVariant {
+  
+}
+
+type AccordionVariantMap = {
+  [key in keyof AccordionVariant]: Array<AccordionVariant[key]>
+}
+
+export type AccordionVariantProps = {
+  [key in keyof AccordionVariant]?: ConditionalValue<AccordionVariant[key]> | undefined
+}
+
+export interface AccordionRecipe {
+  __type: AccordionVariantProps
+  (props?: AccordionVariantProps): Pretty<Record<"root" | "item" | "header" | "trigger" | "content" | "root" | "item" | "header" | "trigger" | "content", string>>
+  raw: (props?: AccordionVariantProps) => AccordionVariantProps
+  variantMap: AccordionVariantMap
+  variantKeys: Array<keyof AccordionVariant>
+  splitVariantProps<Props extends AccordionVariantProps>(props: Props): [AccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionVariantProps>>]
+}
+
+/** Styles for the Accordion component */
+export declare const accordion: AccordionRecipe

package/dist/styled-system/recipes/accordion.mjs

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const accordionDefaultVariants = {}
+const accordionCompoundVariants = []
+
+const accordionSlotNames = [
+  [
+    "root",
+    "accordion__root"
+  ],
+  [
+    "item",
+    "accordion__item"
+  ],
+  [
+    "header",
+    "accordion__header"
+  ],
+  [
+    "trigger",
+    "accordion__trigger"
+  ],
+  [
+    "content",
+    "accordion__content"
+  ],
+  [
+    "root",
+    "accordion__root"
+  ],
+  [
+    "item",
+    "accordion__item"
+  ],
+  [
+    "header",
+    "accordion__header"
+  ],
+  [
+    "trigger",
+    "accordion__trigger"
+  ],
+  [
+    "content",
+    "accordion__content"
+  ]
+]
+const accordionSlotFns = /* @__PURE__ */ accordionSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, accordionDefaultVariants, getSlotCompoundVariant(accordionCompoundVariants, slotName))])
+
+const accordionFn = (props = {}) => {
+  return Object.fromEntries(accordionSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const accordionVariantKeys = []
+
+export const accordion = /* @__PURE__ */ Object.assign(accordionFn, {
+  __recipe__: false,
+  __name__: 'accordion',
+  raw: (props) => props,
+  variantKeys: accordionVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, accordionVariantKeys)
+  },
+})

package/dist/styled-system/recipes/alert-description.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AlertDescriptionVariant {
+  
+}
+
+type AlertDescriptionVariantMap = {
+  [key in keyof AlertDescriptionVariant]: Array<AlertDescriptionVariant[key]>
+}
+
+export type AlertDescriptionVariantProps = {
+  [key in keyof AlertDescriptionVariant]?: ConditionalValue<AlertDescriptionVariant[key]> | undefined
+}
+
+export interface AlertDescriptionRecipe {
+  __type: AlertDescriptionVariantProps
+  (props?: AlertDescriptionVariantProps): string
+  raw: (props?: AlertDescriptionVariantProps) => AlertDescriptionVariantProps
+  variantMap: AlertDescriptionVariantMap
+  variantKeys: Array<keyof AlertDescriptionVariant>
+  splitVariantProps<Props extends AlertDescriptionVariantProps>(props: Props): [AlertDescriptionVariantProps, Pretty<DistributiveOmit<Props, keyof AlertDescriptionVariantProps>>]
+}
+
+/** Styles for the AlertDescription component */
+export declare const alertDescription: AlertDescriptionRecipe

package/dist/styled-system/recipes/alert-description.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const alertDescriptionFn = /* @__PURE__ */ createRecipe('alertDescription', {}, [])
+
+const alertDescriptionVariantMap = {}
+
+const alertDescriptionVariantKeys = Object.keys(alertDescriptionVariantMap)
+
+export const alertDescription = /* @__PURE__ */ Object.assign(alertDescriptionFn, {
+  __recipe__: true,
+  __name__: 'alertDescription',
+  raw: (props) => props,
+  variantKeys: alertDescriptionVariantKeys,
+  variantMap: alertDescriptionVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, alertDescriptionVariantKeys)
+  },
+})

package/dist/styled-system/recipes/alert-dialog.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AlertDialogVariant {
+  
+}
+
+type AlertDialogVariantMap = {
+  [key in keyof AlertDialogVariant]: Array<AlertDialogVariant[key]>
+}
+
+export type AlertDialogVariantProps = {
+  [key in keyof AlertDialogVariant]?: ConditionalValue<AlertDialogVariant[key]> | undefined
+}
+
+export interface AlertDialogRecipe {
+  __type: AlertDialogVariantProps
+  (props?: AlertDialogVariantProps): Pretty<Record<"root" | "trigger" | "portal" | "overlay" | "content" | "header" | "footer" | "title" | "description" | "action" | "cancel" | "root" | "trigger" | "portal" | "overlay" | "content" | "header" | "footer" | "title" | "description" | "action" | "cancel", string>>
+  raw: (props?: AlertDialogVariantProps) => AlertDialogVariantProps
+  variantMap: AlertDialogVariantMap
+  variantKeys: Array<keyof AlertDialogVariant>
+  splitVariantProps<Props extends AlertDialogVariantProps>(props: Props): [AlertDialogVariantProps, Pretty<DistributiveOmit<Props, keyof AlertDialogVariantProps>>]
+}
+
+/** Styles for the AlertDialog component */
+export declare const alertDialog: AlertDialogRecipe

package/dist/styled-system/recipes/alert-dialog.mjs

@@ -0,0 +1,114 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const alertDialogDefaultVariants = {}
+const alertDialogCompoundVariants = []
+
+const alertDialogSlotNames = [
+  [
+    "root",
+    "alertDialog__root"
+  ],
+  [
+    "trigger",
+    "alertDialog__trigger"
+  ],
+  [
+    "portal",
+    "alertDialog__portal"
+  ],
+  [
+    "overlay",
+    "alertDialog__overlay"
+  ],
+  [
+    "content",
+    "alertDialog__content"
+  ],
+  [
+    "header",
+    "alertDialog__header"
+  ],
+  [
+    "footer",
+    "alertDialog__footer"
+  ],
+  [
+    "title",
+    "alertDialog__title"
+  ],
+  [
+    "description",
+    "alertDialog__description"
+  ],
+  [
+    "action",
+    "alertDialog__action"
+  ],
+  [
+    "cancel",
+    "alertDialog__cancel"
+  ],
+  [
+    "root",
+    "alertDialog__root"
+  ],
+  [
+    "trigger",
+    "alertDialog__trigger"
+  ],
+  [
+    "portal",
+    "alertDialog__portal"
+  ],
+  [
+    "overlay",
+    "alertDialog__overlay"
+  ],
+  [
+    "content",
+    "alertDialog__content"
+  ],
+  [
+    "header",
+    "alertDialog__header"
+  ],
+  [
+    "footer",
+    "alertDialog__footer"
+  ],
+  [
+    "title",
+    "alertDialog__title"
+  ],
+  [
+    "description",
+    "alertDialog__description"
+  ],
+  [
+    "action",
+    "alertDialog__action"
+  ],
+  [
+    "cancel",
+    "alertDialog__cancel"
+  ]
+]
+const alertDialogSlotFns = /* @__PURE__ */ alertDialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, alertDialogDefaultVariants, getSlotCompoundVariant(alertDialogCompoundVariants, slotName))])
+
+const alertDialogFn = (props = {}) => {
+  return Object.fromEntries(alertDialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const alertDialogVariantKeys = []
+
+export const alertDialog = /* @__PURE__ */ Object.assign(alertDialogFn, {
+  __recipe__: false,
+  __name__: 'alertDialog',
+  raw: (props) => props,
+  variantKeys: alertDialogVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, alertDialogVariantKeys)
+  },
+})

package/dist/styled-system/recipes/alert-title.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AlertTitleVariant {
+  
+}
+
+type AlertTitleVariantMap = {
+  [key in keyof AlertTitleVariant]: Array<AlertTitleVariant[key]>
+}
+
+export type AlertTitleVariantProps = {
+  [key in keyof AlertTitleVariant]?: ConditionalValue<AlertTitleVariant[key]> | undefined
+}
+
+export interface AlertTitleRecipe {
+  __type: AlertTitleVariantProps
+  (props?: AlertTitleVariantProps): string
+  raw: (props?: AlertTitleVariantProps) => AlertTitleVariantProps
+  variantMap: AlertTitleVariantMap
+  variantKeys: Array<keyof AlertTitleVariant>
+  splitVariantProps<Props extends AlertTitleVariantProps>(props: Props): [AlertTitleVariantProps, Pretty<DistributiveOmit<Props, keyof AlertTitleVariantProps>>]
+}
+
+/** Styles for the AlertTitle component */
+export declare const alertTitle: AlertTitleRecipe

package/dist/styled-system/recipes/alert-title.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const alertTitleFn = /* @__PURE__ */ createRecipe('alertTitle', {}, [])
+
+const alertTitleVariantMap = {}
+
+const alertTitleVariantKeys = Object.keys(alertTitleVariantMap)
+
+export const alertTitle = /* @__PURE__ */ Object.assign(alertTitleFn, {
+  __recipe__: true,
+  __name__: 'alertTitle',
+  raw: (props) => props,
+  variantKeys: alertTitleVariantKeys,
+  variantMap: alertTitleVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, alertTitleVariantKeys)
+  },
+})

package/dist/styled-system/recipes/alert.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AlertVariant {
+  variant: "default" | "destructive"
+}
+
+type AlertVariantMap = {
+  [key in keyof AlertVariant]: Array<AlertVariant[key]>
+}
+
+export type AlertVariantProps = {
+  [key in keyof AlertVariant]?: ConditionalValue<AlertVariant[key]> | undefined
+}
+
+export interface AlertRecipe {
+  __type: AlertVariantProps
+  (props?: AlertVariantProps): string
+  raw: (props?: AlertVariantProps) => AlertVariantProps
+  variantMap: AlertVariantMap
+  variantKeys: Array<keyof AlertVariant>
+  splitVariantProps<Props extends AlertVariantProps>(props: Props): [AlertVariantProps, Pretty<DistributiveOmit<Props, keyof AlertVariantProps>>]
+}
+
+/** Styles for the Alert component */
+export declare const alert: AlertRecipe

package/dist/styled-system/recipes/alert.mjs

@@ -0,0 +1,29 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const alertFn = /* @__PURE__ */ createRecipe('alert', {
+  "variant": "default"
+}, [])
+
+const alertVariantMap = {
+  "variant": [
+    "default",
+    "destructive"
+  ]
+}
+
+const alertVariantKeys = Object.keys(alertVariantMap)
+
+export const alert = /* @__PURE__ */ Object.assign(alertFn, {
+  __recipe__: true,
+  __name__: 'alert',
+  raw: (props) => props,
+  variantKeys: alertVariantKeys,
+  variantMap: alertVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, alertVariantKeys)
+  },
+})

package/dist/styled-system/recipes/avatar.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface AvatarVariant {
+  
+}
+
+type AvatarVariantMap = {
+  [key in keyof AvatarVariant]: Array<AvatarVariant[key]>
+}
+
+export type AvatarVariantProps = {
+  [key in keyof AvatarVariant]?: ConditionalValue<AvatarVariant[key]> | undefined
+}
+
+export interface AvatarRecipe {
+  __type: AvatarVariantProps
+  (props?: AvatarVariantProps): Pretty<Record<"root" | "image" | "fallback" | "root" | "image" | "fallback", string>>
+  raw: (props?: AvatarVariantProps) => AvatarVariantProps
+  variantMap: AvatarVariantMap
+  variantKeys: Array<keyof AvatarVariant>
+  splitVariantProps<Props extends AvatarVariantProps>(props: Props): [AvatarVariantProps, Pretty<DistributiveOmit<Props, keyof AvatarVariantProps>>]
+}
+
+/** Styles for the Avatar component */
+export declare const avatar: AvatarRecipe

package/dist/styled-system/recipes/avatar.mjs

@@ -0,0 +1,50 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const avatarDefaultVariants = {}
+const avatarCompoundVariants = []
+
+const avatarSlotNames = [
+  [
+    "root",
+    "avatar__root"
+  ],
+  [
+    "image",
+    "avatar__image"
+  ],
+  [
+    "fallback",
+    "avatar__fallback"
+  ],
+  [
+    "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 = (props = {}) => {
+  return Object.fromEntries(avatarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const avatarVariantKeys = []
+
+export const avatar = /* @__PURE__ */ Object.assign(avatarFn, {
+  __recipe__: false,
+  __name__: 'avatar',
+  raw: (props) => props,
+  variantKeys: avatarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, avatarVariantKeys)
+  },
+})

package/dist/styled-system/recipes/badge.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface BadgeVariant {
+  variant: "default" | "secondary" | "destructive" | "outline"
+}
+
+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>>]
+}
+
+/** Styles for the Badge component */
+export declare const badge: BadgeRecipe

package/dist/styled-system/recipes/badge.mjs

@@ -0,0 +1,31 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const badgeFn = /* @__PURE__ */ createRecipe('badge', {
+  "variant": "default"
+}, [])
+
+const badgeVariantMap = {
+  "variant": [
+    "default",
+    "secondary",
+    "destructive",
+    "outline"
+  ]
+}
+
+const badgeVariantKeys = Object.keys(badgeVariantMap)
+
+export const badge = /* @__PURE__ */ Object.assign(badgeFn, {
+  __recipe__: true,
+  __name__: 'badge',
+  raw: (props) => props,
+  variantKeys: badgeVariantKeys,
+  variantMap: badgeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, badgeVariantKeys)
+  },
+})

package/dist/styled-system/recipes/blockquote.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface BlockquoteVariant {
+  
+}
+
+type BlockquoteVariantMap = {
+  [key in keyof BlockquoteVariant]: Array<BlockquoteVariant[key]>
+}
+
+export type BlockquoteVariantProps = {
+  [key in keyof BlockquoteVariant]?: ConditionalValue<BlockquoteVariant[key]> | undefined
+}
+
+export interface BlockquoteRecipe {
+  __type: BlockquoteVariantProps
+  (props?: BlockquoteVariantProps): string
+  raw: (props?: BlockquoteVariantProps) => BlockquoteVariantProps
+  variantMap: BlockquoteVariantMap
+  variantKeys: Array<keyof BlockquoteVariant>
+  splitVariantProps<Props extends BlockquoteVariantProps>(props: Props): [BlockquoteVariantProps, Pretty<DistributiveOmit<Props, keyof BlockquoteVariantProps>>]
+}
+
+/** Typography - blockquote style */
+export declare const blockquote: BlockquoteRecipe

package/dist/styled-system/recipes/blockquote.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const blockquoteFn = /* @__PURE__ */ createRecipe('blockquote', {}, [])
+
+const blockquoteVariantMap = {}
+
+const blockquoteVariantKeys = Object.keys(blockquoteVariantMap)
+
+export const blockquote = /* @__PURE__ */ Object.assign(blockquoteFn, {
+  __recipe__: true,
+  __name__: 'blockquote',
+  raw: (props) => props,
+  variantKeys: blockquoteVariantKeys,
+  variantMap: blockquoteVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, blockquoteVariantKeys)
+  },
+})