@luxonis/common-fe-components 1.9.5

package/dist/styled-system/recipes/toast.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 ToastVariant {
+  variant: "default" | "destructive"
+}
+
+type ToastVariantMap = {
+  [key in keyof ToastVariant]: Array<ToastVariant[key]>
+}
+
+export type ToastVariantProps = {
+  [key in keyof ToastVariant]?: ConditionalValue<ToastVariant[key]> | undefined
+}
+
+export interface ToastRecipe {
+  __type: ToastVariantProps
+  (props?: ToastVariantProps): Pretty<Record<"root" | "viewport" | "action" | "close" | "title" | "description" | "root" | "viewport" | "action" | "close" | "title" | "description", string>>
+  raw: (props?: ToastVariantProps) => ToastVariantProps
+  variantMap: ToastVariantMap
+  variantKeys: Array<keyof ToastVariant>
+  splitVariantProps<Props extends ToastVariantProps>(props: Props): [ToastVariantProps, Pretty<DistributiveOmit<Props, keyof ToastVariantProps>>]
+}
+
+/** Styles for the Toast component */
+export declare const toast: ToastRecipe

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

@@ -0,0 +1,83 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toastDefaultVariants = {
+  "variant": "default"
+}
+const toastCompoundVariants = []
+
+const toastSlotNames = [
+  [
+    "root",
+    "toast__root"
+  ],
+  [
+    "viewport",
+    "toast__viewport"
+  ],
+  [
+    "action",
+    "toast__action"
+  ],
+  [
+    "close",
+    "toast__close"
+  ],
+  [
+    "title",
+    "toast__title"
+  ],
+  [
+    "description",
+    "toast__description"
+  ],
+  [
+    "root",
+    "toast__root"
+  ],
+  [
+    "viewport",
+    "toast__viewport"
+  ],
+  [
+    "action",
+    "toast__action"
+  ],
+  [
+    "close",
+    "toast__close"
+  ],
+  [
+    "title",
+    "toast__title"
+  ],
+  [
+    "description",
+    "toast__description"
+  ]
+]
+const toastSlotFns = /* @__PURE__ */ toastSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toastDefaultVariants, getSlotCompoundVariant(toastCompoundVariants, slotName))])
+
+const toastFn = (props = {}) => {
+  return Object.fromEntries(toastSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const toastVariantKeys = [
+  "variant"
+]
+
+export const toast = /* @__PURE__ */ Object.assign(toastFn, {
+  __recipe__: false,
+  __name__: 'toast',
+  raw: (props) => props,
+  variantKeys: toastVariantKeys,
+  variantMap: {
+  "variant": [
+    "default",
+    "destructive"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, toastVariantKeys)
+  },
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
+
+interface ToggleVariant {
+  variant: "default" | "outline"
+size: "default" | "sm" | "lg"
+}
+
+type ToggleVariantMap = {
+  [key in keyof ToggleVariant]: Array<ToggleVariant[key]>
+}
+
+export type ToggleVariantProps = {
+  [key in keyof ToggleVariant]?: ConditionalValue<ToggleVariant[key]> | undefined
+}
+
+export interface ToggleRecipe {
+  __type: ToggleVariantProps
+  (props?: ToggleVariantProps): string
+  raw: (props?: ToggleVariantProps) => ToggleVariantProps
+  variantMap: ToggleVariantMap
+  variantKeys: Array<keyof ToggleVariant>
+  splitVariantProps<Props extends ToggleVariantProps>(props: Props): [ToggleVariantProps, Pretty<DistributiveOmit<Props, keyof ToggleVariantProps>>]
+}
+
+/** Styles for the Toggle component */
+export declare const toggle: ToggleRecipe

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

@@ -0,0 +1,35 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const toggleFn = /* @__PURE__ */ createRecipe('toggle', {
+  "variant": "default",
+  "size": "default"
+}, [])
+
+const toggleVariantMap = {
+  "variant": [
+    "default",
+    "outline"
+  ],
+  "size": [
+    "default",
+    "sm",
+    "lg"
+  ]
+}
+
+const toggleVariantKeys = Object.keys(toggleVariantMap)
+
+export const toggle = /* @__PURE__ */ Object.assign(toggleFn, {
+  __recipe__: true,
+  __name__: 'toggle',
+  raw: (props) => props,
+  variantKeys: toggleVariantKeys,
+  variantMap: toggleVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, toggleVariantKeys)
+  },
+})

package/dist/styled-system/recipes/tooltip.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 TooltipVariant {
+  
+}
+
+type TooltipVariantMap = {
+  [key in keyof TooltipVariant]: Array<TooltipVariant[key]>
+}
+
+export type TooltipVariantProps = {
+  [key in keyof TooltipVariant]?: ConditionalValue<TooltipVariant[key]> | undefined
+}
+
+export interface TooltipRecipe {
+  __type: TooltipVariantProps
+  (props?: TooltipVariantProps): Pretty<Record<"root" | "trigger" | "content" | "root" | "trigger" | "content", string>>
+  raw: (props?: TooltipVariantProps) => TooltipVariantProps
+  variantMap: TooltipVariantMap
+  variantKeys: Array<keyof TooltipVariant>
+  splitVariantProps<Props extends TooltipVariantProps>(props: Props): [TooltipVariantProps, Pretty<DistributiveOmit<Props, keyof TooltipVariantProps>>]
+}
+
+/** Styles for the Tooltip component */
+export declare const tooltip: TooltipRecipe

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

@@ -0,0 +1,50 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tooltipDefaultVariants = {}
+const tooltipCompoundVariants = []
+
+const tooltipSlotNames = [
+  [
+    "root",
+    "tooltip__root"
+  ],
+  [
+    "trigger",
+    "tooltip__trigger"
+  ],
+  [
+    "content",
+    "tooltip__content"
+  ],
+  [
+    "root",
+    "tooltip__root"
+  ],
+  [
+    "trigger",
+    "tooltip__trigger"
+  ],
+  [
+    "content",
+    "tooltip__content"
+  ]
+]
+const tooltipSlotFns = /* @__PURE__ */ tooltipSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tooltipDefaultVariants, getSlotCompoundVariant(tooltipCompoundVariants, slotName))])
+
+const tooltipFn = (props = {}) => {
+  return Object.fromEntries(tooltipSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const tooltipVariantKeys = []
+
+export const tooltip = /* @__PURE__ */ Object.assign(tooltipFn, {
+  __recipe__: false,
+  __name__: 'tooltip',
+  raw: (props) => props,
+  variantKeys: tooltipVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tooltipVariantKeys)
+  },
+})

package/dist/styled-system/recipes/typography-table-container.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 TypographyTableContainerVariant {
+  
+}
+
+type TypographyTableContainerVariantMap = {
+  [key in keyof TypographyTableContainerVariant]: Array<TypographyTableContainerVariant[key]>
+}
+
+export type TypographyTableContainerVariantProps = {
+  [key in keyof TypographyTableContainerVariant]?: ConditionalValue<TypographyTableContainerVariant[key]> | undefined
+}
+
+export interface TypographyTableContainerRecipe {
+  __type: TypographyTableContainerVariantProps
+  (props?: TypographyTableContainerVariantProps): string
+  raw: (props?: TypographyTableContainerVariantProps) => TypographyTableContainerVariantProps
+  variantMap: TypographyTableContainerVariantMap
+  variantKeys: Array<keyof TypographyTableContainerVariant>
+  splitVariantProps<Props extends TypographyTableContainerVariantProps>(props: Props): [TypographyTableContainerVariantProps, Pretty<DistributiveOmit<Props, keyof TypographyTableContainerVariantProps>>]
+}
+
+/** Typography - table container style */
+export declare const typographyTableContainer: TypographyTableContainerRecipe

package/dist/styled-system/recipes/typography-table-container.mjs

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

package/dist/styled-system/recipes/typography-table.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 TypographyTableVariant {
+  
+}
+
+type TypographyTableVariantMap = {
+  [key in keyof TypographyTableVariant]: Array<TypographyTableVariant[key]>
+}
+
+export type TypographyTableVariantProps = {
+  [key in keyof TypographyTableVariant]?: ConditionalValue<TypographyTableVariant[key]> | undefined
+}
+
+export interface TypographyTableRecipe {
+  __type: TypographyTableVariantProps
+  (props?: TypographyTableVariantProps): string
+  raw: (props?: TypographyTableVariantProps) => TypographyTableVariantProps
+  variantMap: TypographyTableVariantMap
+  variantKeys: Array<keyof TypographyTableVariant>
+  splitVariantProps<Props extends TypographyTableVariantProps>(props: Props): [TypographyTableVariantProps, Pretty<DistributiveOmit<Props, keyof TypographyTableVariantProps>>]
+}
+
+/** Typography - table style */
+export declare const typographyTable: TypographyTableRecipe

package/dist/styled-system/recipes/typography-table.mjs

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

package/dist/styled-system/tokens/index.d.mts

@@ -0,0 +1,9 @@
+/* eslint-disable */
+import type { Token } from './tokens.d.mts';
+
+export declare const token: {
+  (path: Token, fallback?: string): string
+  var: (path: Token, fallback?: string) => string
+}
+
+export * from './tokens.d.mts';