@luxonis/depthai-pipeline-lib 3.4.0-rc.2 → 3.5.0

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

@@ -1,36 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const progressDefaultVariants = {}
-const progressCompoundVariants = []
-
-const progressSlotNames = [
-  [
-    "root",
-    "progress__root"
-  ],
-  [
-    "indicator",
-    "progress__indicator"
-  ]
-]
-const progressSlotFns = /* @__PURE__ */ progressSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressDefaultVariants, getSlotCompoundVariant(progressCompoundVariants, slotName))])
-
-const progressFn = memo((props = {}) => {
-  return Object.fromEntries(progressSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const progressVariantKeys = []
-const getVariantProps = (variants) => ({ ...progressDefaultVariants, ...compact(variants) })
-
-export const progress = /* @__PURE__ */ Object.assign(progressFn, {
-  __recipe__: false,
-  __name__: 'progress',
-  raw: (props) => props,
-  variantKeys: progressVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, progressVariantKeys)
-  },
-  getVariantProps
-})

package/dist/src/styled-system/recipes/radio-group.d.mts

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
-
-interface RadioGroupVariant {
-  
-}
-
-type RadioGroupVariantMap = {
-  [key in keyof RadioGroupVariant]: Array<RadioGroupVariant[key]>
-}
-
-export type RadioGroupVariantProps = {
-  [key in keyof RadioGroupVariant]?: ConditionalValue<RadioGroupVariant[key]> | undefined
-}
-
-export interface RadioGroupRecipe {
-  __type: RadioGroupVariantProps
-  (props?: RadioGroupVariantProps): Pretty<Record<"root" | "item" | "indicator" | "icon", string>>
-  raw: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
-  variantMap: RadioGroupVariantMap
-  variantKeys: Array<keyof RadioGroupVariant>
-  splitVariantProps<Props extends RadioGroupVariantProps>(props: Props): [RadioGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioGroupVariantProps>>]
-  getVariantProps: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
-}
-
-/**
- * Styles for the RadioGroup component
-
-
- */
-export declare const radioGroup: RadioGroupRecipe

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

@@ -1,44 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } 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 = memo((props = {}) => {
-  return Object.fromEntries(radioGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const radioGroupVariantKeys = []
-const getVariantProps = (variants) => ({ ...radioGroupDefaultVariants, ...compact(variants) })
-
-export const radioGroup = /* @__PURE__ */ Object.assign(radioGroupFn, {
-  __recipe__: false,
-  __name__: 'radioGroup',
-  raw: (props) => props,
-  variantKeys: radioGroupVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, radioGroupVariantKeys)
-  },
-  getVariantProps
-})

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

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } 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]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: ScrollAreaVariantProps) => ScrollAreaVariantProps
-}
-
-/**
- * Styles for the ScrollArea component
-
-
- */
-export declare const scrollArea: ScrollAreaRecipe

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

@@ -1,48 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } 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 = memo((props = {}) => {
-  return Object.fromEntries(scrollAreaSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const scrollAreaVariantKeys = []
-const getVariantProps = (variants) => ({ ...scrollAreaDefaultVariants, ...compact(variants) })
-
-export const scrollArea = /* @__PURE__ */ Object.assign(scrollAreaFn, {
-  __recipe__: false,
-  __name__: 'scrollArea',
-  raw: (props) => props,
-  variantKeys: scrollAreaVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, scrollAreaVariantKeys)
-  },
-  getVariantProps
-})

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

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } 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]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SelectVariantProps) => SelectVariantProps
-}
-
-/**
- * Styles for the Select component
-
-
- */
-export declare const select: SelectRecipe

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

@@ -1,68 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } 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 = memo((props = {}) => {
-  return Object.fromEntries(selectSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const selectVariantKeys = []
-const getVariantProps = (variants) => ({ ...selectDefaultVariants, ...compact(variants) })
-
-export const select = /* @__PURE__ */ Object.assign(selectFn, {
-  __recipe__: false,
-  __name__: 'select',
-  raw: (props) => props,
-  variantKeys: selectVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, selectVariantKeys)
-  },
-  getVariantProps
-})

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

@@ -1,35 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
-
-interface SeparatorVariant {
-  /**
- * @default "horizontal"
- */
-orientation: "horizontal" | "vertical"
-}
-
-type SeparatorVariantMap = {
-  [key in keyof SeparatorVariant]: Array<SeparatorVariant[key]>
-}
-
-export type SeparatorVariantProps = {
-  [key in keyof SeparatorVariant]?: ConditionalValue<SeparatorVariant[key]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SeparatorVariantProps) => SeparatorVariantProps
-}
-
-/**
- * Styles for the Separator component
-
-
- */
-export declare const separator: SeparatorRecipe

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

@@ -1,31 +0,0 @@
-import { memo, splitProps } from '../helpers.mjs';
-import { createRecipe, mergeRecipes } 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(memo(separatorFn.recipeFn), {
-  __recipe__: true,
-  __name__: 'separator',
-  __getCompoundVariantCss__: separatorFn.__getCompoundVariantCss__,
-  raw: (props) => props,
-  variantKeys: separatorVariantKeys,
-  variantMap: separatorVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
-  splitVariantProps(props) {
-    return splitProps(props, separatorVariantKeys)
-  },
-  getVariantProps: separatorFn.getVariantProps,
-})

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

@@ -1,35 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } from '../types/system-types.d.mts';
-
-interface SheetVariant {
-  /**
- * @default "right"
- */
-side: "top" | "bottom" | "left" | "right"
-}
-
-type SheetVariantMap = {
-  [key in keyof SheetVariant]: Array<SheetVariant[key]>
-}
-
-export type SheetVariantProps = {
-  [key in keyof SheetVariant]?: ConditionalValue<SheetVariant[key]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SheetVariantProps) => SheetVariantProps
-}
-
-/**
- * Styles for the Sheet component
-
-
- */
-export declare const sheet: SheetRecipe

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

@@ -1,83 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } 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 = memo((props = {}) => {
-  return Object.fromEntries(sheetSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const sheetVariantKeys = [
-  "side"
-]
-const getVariantProps = (variants) => ({ ...sheetDefaultVariants, ...compact(variants) })
-
-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)
-  },
-  getVariantProps
-})

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

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } 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]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SkeletonVariantProps) => SkeletonVariantProps
-}
-
-/**
- * Styles for the Skeleton component
-
-
- */
-export declare const skeleton: SkeletonRecipe

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

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

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

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } 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]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SliderVariantProps) => SliderVariantProps
-}
-
-/**
- * Styles for the Slider component
-
-
- */
-export declare const slider: SliderRecipe

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

@@ -1,44 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } 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 = memo((props = {}) => {
-  return Object.fromEntries(sliderSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const sliderVariantKeys = []
-const getVariantProps = (variants) => ({ ...sliderDefaultVariants, ...compact(variants) })
-
-export const slider = /* @__PURE__ */ Object.assign(sliderFn, {
-  __recipe__: false,
-  __name__: 'slider',
-  raw: (props) => props,
-  variantKeys: sliderVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, sliderVariantKeys)
-  },
-  getVariantProps
-})

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

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index.d.mts';
-import type { DistributiveOmit, Pretty } 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]> | undefined
-}
-
-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>>]
-  getVariantProps: (props?: SmallVariantProps) => SmallVariantProps
-}
-
-/**
- * Typography - Small style
-
-
- */
-export declare const small: SmallRecipe

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

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