@luxonis/depthai-pipeline-lib 1.4.8

package/dist/src/styled-system/recipes/radio-group.mjs

@@ -0,0 +1,42 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioGroupDefaultVariants = {}
+const radioGroupCompoundVariants = []
+
+const radioGroupSlotNames = [
+  [
+    "root",
+    "radioGroup__root"
+  ],
+  [
+    "item",
+    "radioGroup__item"
+  ],
+  [
+    "indicator",
+    "radioGroup__indicator"
+  ],
+  [
+    "icon",
+    "radioGroup__icon"
+  ]
+]
+const radioGroupSlotFns = /* @__PURE__ */ radioGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioGroupDefaultVariants, getSlotCompoundVariant(radioGroupCompoundVariants, slotName))])
+
+const radioGroupFn = (props = {}) => {
+  return Object.fromEntries(radioGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const radioGroupVariantKeys = []
+
+export const radioGroup = /* @__PURE__ */ Object.assign(radioGroupFn, {
+  __recipe__: false,
+  __name__: 'radioGroup',
+  raw: (props) => props,
+  variantKeys: radioGroupVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, radioGroupVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/scroll-area.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface ScrollAreaVariant {
+  
+}
+
+type ScrollAreaVariantMap = {
+  [key in keyof ScrollAreaVariant]: Array<ScrollAreaVariant[key]>
+}
+
+export type ScrollAreaVariantProps = {
+  [key in keyof ScrollAreaVariant]?: ConditionalValue<ScrollAreaVariant[key]>
+}
+
+export interface ScrollAreaRecipe {
+  __type: ScrollAreaVariantProps
+  (props?: ScrollAreaVariantProps): Pretty<Record<"root" | "viewport" | "corner" | "scrollbar" | "thumb", string>>
+  raw: (props?: ScrollAreaVariantProps) => ScrollAreaVariantProps
+  variantMap: ScrollAreaVariantMap
+  variantKeys: Array<keyof ScrollAreaVariant>
+  splitVariantProps<Props extends ScrollAreaVariantProps>(props: Props): [ScrollAreaVariantProps, Pretty<DistributiveOmit<Props, keyof ScrollAreaVariantProps>>]
+}
+
+/** Styles for the ScrollArea component */
+export declare const scrollArea: ScrollAreaRecipe

package/dist/src/styled-system/recipes/scroll-area.mjs

@@ -0,0 +1,46 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const scrollAreaDefaultVariants = {}
+const scrollAreaCompoundVariants = []
+
+const scrollAreaSlotNames = [
+  [
+    "root",
+    "scrollArea__root"
+  ],
+  [
+    "viewport",
+    "scrollArea__viewport"
+  ],
+  [
+    "corner",
+    "scrollArea__corner"
+  ],
+  [
+    "scrollbar",
+    "scrollArea__scrollbar"
+  ],
+  [
+    "thumb",
+    "scrollArea__thumb"
+  ]
+]
+const scrollAreaSlotFns = /* @__PURE__ */ scrollAreaSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, scrollAreaDefaultVariants, getSlotCompoundVariant(scrollAreaCompoundVariants, slotName))])
+
+const scrollAreaFn = (props = {}) => {
+  return Object.fromEntries(scrollAreaSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const scrollAreaVariantKeys = []
+
+export const scrollArea = /* @__PURE__ */ Object.assign(scrollAreaFn, {
+  __recipe__: false,
+  __name__: 'scrollArea',
+  raw: (props) => props,
+  variantKeys: scrollAreaVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, scrollAreaVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/select.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SelectVariant {
+  
+}
+
+type SelectVariantMap = {
+  [key in keyof SelectVariant]: Array<SelectVariant[key]>
+}
+
+export type SelectVariantProps = {
+  [key in keyof SelectVariant]?: ConditionalValue<SelectVariant[key]>
+}
+
+export interface SelectRecipe {
+  __type: SelectVariantProps
+  (props?: SelectVariantProps): Pretty<Record<"root" | "group" | "value" | "trigger" | "viewport" | "content" | "label" | "item" | "itemIndicator" | "separator", string>>
+  raw: (props?: SelectVariantProps) => SelectVariantProps
+  variantMap: SelectVariantMap
+  variantKeys: Array<keyof SelectVariant>
+  splitVariantProps<Props extends SelectVariantProps>(props: Props): [SelectVariantProps, Pretty<DistributiveOmit<Props, keyof SelectVariantProps>>]
+}
+
+/** Styles for the Select component */
+export declare const select: SelectRecipe

package/dist/src/styled-system/recipes/select.mjs

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const selectDefaultVariants = {}
+const selectCompoundVariants = []
+
+const selectSlotNames = [
+  [
+    "root",
+    "select__root"
+  ],
+  [
+    "group",
+    "select__group"
+  ],
+  [
+    "value",
+    "select__value"
+  ],
+  [
+    "trigger",
+    "select__trigger"
+  ],
+  [
+    "viewport",
+    "select__viewport"
+  ],
+  [
+    "content",
+    "select__content"
+  ],
+  [
+    "label",
+    "select__label"
+  ],
+  [
+    "item",
+    "select__item"
+  ],
+  [
+    "itemIndicator",
+    "select__itemIndicator"
+  ],
+  [
+    "separator",
+    "select__separator"
+  ]
+]
+const selectSlotFns = /* @__PURE__ */ selectSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, selectDefaultVariants, getSlotCompoundVariant(selectCompoundVariants, slotName))])
+
+const selectFn = (props = {}) => {
+  return Object.fromEntries(selectSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const selectVariantKeys = []
+
+export const select = /* @__PURE__ */ Object.assign(selectFn, {
+  __recipe__: false,
+  __name__: 'select',
+  raw: (props) => props,
+  variantKeys: selectVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, selectVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/separator.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SeparatorVariant {
+  orientation: "horizontal" | "vertical"
+}
+
+type SeparatorVariantMap = {
+  [key in keyof SeparatorVariant]: Array<SeparatorVariant[key]>
+}
+
+export type SeparatorVariantProps = {
+  [key in keyof SeparatorVariant]?: ConditionalValue<SeparatorVariant[key]>
+}
+
+export interface SeparatorRecipe {
+  __type: SeparatorVariantProps
+  (props?: SeparatorVariantProps): string
+  raw: (props?: SeparatorVariantProps) => SeparatorVariantProps
+  variantMap: SeparatorVariantMap
+  variantKeys: Array<keyof SeparatorVariant>
+  splitVariantProps<Props extends SeparatorVariantProps>(props: Props): [SeparatorVariantProps, Pretty<DistributiveOmit<Props, keyof SeparatorVariantProps>>]
+}
+
+/** Styles for the Separator component */
+export declare const separator: SeparatorRecipe

package/dist/src/styled-system/recipes/separator.mjs

@@ -0,0 +1,26 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const separatorFn = /* @__PURE__ */ createRecipe('separator', {
+  "orientation": "horizontal"
+}, [])
+
+const separatorVariantMap = {
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ]
+}
+
+const separatorVariantKeys = Object.keys(separatorVariantMap)
+
+export const separator = /* @__PURE__ */ Object.assign(separatorFn, {
+  __recipe__: true,
+  __name__: 'separator',
+  raw: (props) => props,
+  variantKeys: separatorVariantKeys,
+  variantMap: separatorVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, separatorVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/sheet.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SheetVariant {
+  side: "top" | "bottom" | "left" | "right"
+}
+
+type SheetVariantMap = {
+  [key in keyof SheetVariant]: Array<SheetVariant[key]>
+}
+
+export type SheetVariantProps = {
+  [key in keyof SheetVariant]?: ConditionalValue<SheetVariant[key]>
+}
+
+export interface SheetRecipe {
+  __type: SheetVariantProps
+  (props?: SheetVariantProps): Pretty<Record<"root" | "trigger" | "close" | "portal" | "overlay" | "header" | "footer" | "title" | "description" | "content" | "contentClose", string>>
+  raw: (props?: SheetVariantProps) => SheetVariantProps
+  variantMap: SheetVariantMap
+  variantKeys: Array<keyof SheetVariant>
+  splitVariantProps<Props extends SheetVariantProps>(props: Props): [SheetVariantProps, Pretty<DistributiveOmit<Props, keyof SheetVariantProps>>]
+}
+
+/** Styles for the Sheet component */
+export declare const sheet: SheetRecipe

package/dist/src/styled-system/recipes/sheet.mjs

@@ -0,0 +1,81 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const sheetDefaultVariants = {
+  "side": "right"
+}
+const sheetCompoundVariants = []
+
+const sheetSlotNames = [
+  [
+    "root",
+    "sheet__root"
+  ],
+  [
+    "trigger",
+    "sheet__trigger"
+  ],
+  [
+    "close",
+    "sheet__close"
+  ],
+  [
+    "portal",
+    "sheet__portal"
+  ],
+  [
+    "overlay",
+    "sheet__overlay"
+  ],
+  [
+    "header",
+    "sheet__header"
+  ],
+  [
+    "footer",
+    "sheet__footer"
+  ],
+  [
+    "title",
+    "sheet__title"
+  ],
+  [
+    "description",
+    "sheet__description"
+  ],
+  [
+    "content",
+    "sheet__content"
+  ],
+  [
+    "contentClose",
+    "sheet__contentClose"
+  ]
+]
+const sheetSlotFns = /* @__PURE__ */ sheetSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sheetDefaultVariants, getSlotCompoundVariant(sheetCompoundVariants, slotName))])
+
+const sheetFn = (props = {}) => {
+  return Object.fromEntries(sheetSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const sheetVariantKeys = [
+  "side"
+]
+
+export const sheet = /* @__PURE__ */ Object.assign(sheetFn, {
+  __recipe__: false,
+  __name__: 'sheet',
+  raw: (props) => props,
+  variantKeys: sheetVariantKeys,
+  variantMap: {
+  "side": [
+    "top",
+    "bottom",
+    "left",
+    "right"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, sheetVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/skeleton.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SkeletonVariant {
+  
+}
+
+type SkeletonVariantMap = {
+  [key in keyof SkeletonVariant]: Array<SkeletonVariant[key]>
+}
+
+export type SkeletonVariantProps = {
+  [key in keyof SkeletonVariant]?: ConditionalValue<SkeletonVariant[key]>
+}
+
+export interface SkeletonRecipe {
+  __type: SkeletonVariantProps
+  (props?: SkeletonVariantProps): string
+  raw: (props?: SkeletonVariantProps) => SkeletonVariantProps
+  variantMap: SkeletonVariantMap
+  variantKeys: Array<keyof SkeletonVariant>
+  splitVariantProps<Props extends SkeletonVariantProps>(props: Props): [SkeletonVariantProps, Pretty<DistributiveOmit<Props, keyof SkeletonVariantProps>>]
+}
+
+/** Styles for the Skeleton component */
+export declare const skeleton: SkeletonRecipe

package/dist/src/styled-system/recipes/skeleton.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const skeletonFn = /* @__PURE__ */ createRecipe('skeleton', {}, [])
+
+const skeletonVariantMap = {}
+
+const skeletonVariantKeys = Object.keys(skeletonVariantMap)
+
+export const skeleton = /* @__PURE__ */ Object.assign(skeletonFn, {
+  __recipe__: true,
+  __name__: 'skeleton',
+  raw: (props) => props,
+  variantKeys: skeletonVariantKeys,
+  variantMap: skeletonVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, skeletonVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/slider.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SliderVariant {
+  
+}
+
+type SliderVariantMap = {
+  [key in keyof SliderVariant]: Array<SliderVariant[key]>
+}
+
+export type SliderVariantProps = {
+  [key in keyof SliderVariant]?: ConditionalValue<SliderVariant[key]>
+}
+
+export interface SliderRecipe {
+  __type: SliderVariantProps
+  (props?: SliderVariantProps): Pretty<Record<"root" | "track" | "range" | "thumb", string>>
+  raw: (props?: SliderVariantProps) => SliderVariantProps
+  variantMap: SliderVariantMap
+  variantKeys: Array<keyof SliderVariant>
+  splitVariantProps<Props extends SliderVariantProps>(props: Props): [SliderVariantProps, Pretty<DistributiveOmit<Props, keyof SliderVariantProps>>]
+}
+
+/** Styles for the Slider component */
+export declare const slider: SliderRecipe

package/dist/src/styled-system/recipes/slider.mjs

@@ -0,0 +1,42 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const sliderDefaultVariants = {}
+const sliderCompoundVariants = []
+
+const sliderSlotNames = [
+  [
+    "root",
+    "slider__root"
+  ],
+  [
+    "track",
+    "slider__track"
+  ],
+  [
+    "range",
+    "slider__range"
+  ],
+  [
+    "thumb",
+    "slider__thumb"
+  ]
+]
+const sliderSlotFns = /* @__PURE__ */ sliderSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, sliderDefaultVariants, getSlotCompoundVariant(sliderCompoundVariants, slotName))])
+
+const sliderFn = (props = {}) => {
+  return Object.fromEntries(sliderSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const sliderVariantKeys = []
+
+export const slider = /* @__PURE__ */ Object.assign(sliderFn, {
+  __recipe__: false,
+  __name__: 'slider',
+  raw: (props) => props,
+  variantKeys: sliderVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, sliderVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/small.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SmallVariant {
+  
+}
+
+type SmallVariantMap = {
+  [key in keyof SmallVariant]: Array<SmallVariant[key]>
+}
+
+export type SmallVariantProps = {
+  [key in keyof SmallVariant]?: ConditionalValue<SmallVariant[key]>
+}
+
+export interface SmallRecipe {
+  __type: SmallVariantProps
+  (props?: SmallVariantProps): string
+  raw: (props?: SmallVariantProps) => SmallVariantProps
+  variantMap: SmallVariantMap
+  variantKeys: Array<keyof SmallVariant>
+  splitVariantProps<Props extends SmallVariantProps>(props: Props): [SmallVariantProps, Pretty<DistributiveOmit<Props, keyof SmallVariantProps>>]
+}
+
+/** Typography - Small style */
+export declare const small: SmallRecipe

package/dist/src/styled-system/recipes/small.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const smallFn = /* @__PURE__ */ createRecipe('small', {}, [])
+
+const smallVariantMap = {}
+
+const smallVariantKeys = Object.keys(smallVariantMap)
+
+export const small = /* @__PURE__ */ Object.assign(smallFn, {
+  __recipe__: true,
+  __name__: 'small',
+  raw: (props) => props,
+  variantKeys: smallVariantKeys,
+  variantMap: smallVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, smallVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/switch-recipe.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface SwitchRecipeVariant {
+  
+}
+
+type SwitchRecipeVariantMap = {
+  [key in keyof SwitchRecipeVariant]: Array<SwitchRecipeVariant[key]>
+}
+
+export type SwitchRecipeVariantProps = {
+  [key in keyof SwitchRecipeVariant]?: ConditionalValue<SwitchRecipeVariant[key]>
+}
+
+export interface SwitchRecipeRecipe {
+  __type: SwitchRecipeVariantProps
+  (props?: SwitchRecipeVariantProps): Pretty<Record<"root" | "thumb", string>>
+  raw: (props?: SwitchRecipeVariantProps) => SwitchRecipeVariantProps
+  variantMap: SwitchRecipeVariantMap
+  variantKeys: Array<keyof SwitchRecipeVariant>
+  splitVariantProps<Props extends SwitchRecipeVariantProps>(props: Props): [SwitchRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SwitchRecipeVariantProps>>]
+}
+
+/** Styles for the Switch component */
+export declare const switchRecipe: SwitchRecipeRecipe

package/dist/src/styled-system/recipes/switch-recipe.mjs

@@ -0,0 +1,34 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const switchRecipeDefaultVariants = {}
+const switchRecipeCompoundVariants = []
+
+const switchRecipeSlotNames = [
+  [
+    "root",
+    "switchRecipe__root"
+  ],
+  [
+    "thumb",
+    "switchRecipe__thumb"
+  ]
+]
+const switchRecipeSlotFns = /* @__PURE__ */ switchRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, switchRecipeDefaultVariants, getSlotCompoundVariant(switchRecipeCompoundVariants, slotName))])
+
+const switchRecipeFn = (props = {}) => {
+  return Object.fromEntries(switchRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const switchRecipeVariantKeys = []
+
+export const switchRecipe = /* @__PURE__ */ Object.assign(switchRecipeFn, {
+  __recipe__: false,
+  __name__: 'switchRecipe',
+  raw: (props) => props,
+  variantKeys: switchRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, switchRecipeVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/table-body.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface TableBodyVariant {
+  
+}
+
+type TableBodyVariantMap = {
+  [key in keyof TableBodyVariant]: Array<TableBodyVariant[key]>
+}
+
+export type TableBodyVariantProps = {
+  [key in keyof TableBodyVariant]?: ConditionalValue<TableBodyVariant[key]>
+}
+
+export interface TableBodyRecipe {
+  __type: TableBodyVariantProps
+  (props?: TableBodyVariantProps): string
+  raw: (props?: TableBodyVariantProps) => TableBodyVariantProps
+  variantMap: TableBodyVariantMap
+  variantKeys: Array<keyof TableBodyVariant>
+  splitVariantProps<Props extends TableBodyVariantProps>(props: Props): [TableBodyVariantProps, Pretty<DistributiveOmit<Props, keyof TableBodyVariantProps>>]
+}
+
+/** Styles for the TableBody component */
+export declare const tableBody: TableBodyRecipe

package/dist/src/styled-system/recipes/table-body.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableBodyFn = /* @__PURE__ */ createRecipe('tableBody', {}, [])
+
+const tableBodyVariantMap = {}
+
+const tableBodyVariantKeys = Object.keys(tableBodyVariantMap)
+
+export const tableBody = /* @__PURE__ */ Object.assign(tableBodyFn, {
+  __recipe__: true,
+  __name__: 'tableBody',
+  raw: (props) => props,
+  variantKeys: tableBodyVariantKeys,
+  variantMap: tableBodyVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, tableBodyVariantKeys)
+  },
+})