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

package/dist/src/styled-system/recipes/card-footer.mjs

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

package/dist/src/styled-system/recipes/card-header.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 CardHeaderVariant {
-  
-}
-
-type CardHeaderVariantMap = {
-  [key in keyof CardHeaderVariant]: Array<CardHeaderVariant[key]>
-}
-
-export type CardHeaderVariantProps = {
-  [key in keyof CardHeaderVariant]?: ConditionalValue<CardHeaderVariant[key]> | undefined
-}
-
-export interface CardHeaderRecipe {
-  __type: CardHeaderVariantProps
-  (props?: CardHeaderVariantProps): string
-  raw: (props?: CardHeaderVariantProps) => CardHeaderVariantProps
-  variantMap: CardHeaderVariantMap
-  variantKeys: Array<keyof CardHeaderVariant>
-  splitVariantProps<Props extends CardHeaderVariantProps>(props: Props): [CardHeaderVariantProps, Pretty<DistributiveOmit<Props, keyof CardHeaderVariantProps>>]
-  getVariantProps: (props?: CardHeaderVariantProps) => CardHeaderVariantProps
-}
-
-/**
- * Styles for the CardHeader component
-
-
- */
-export declare const cardHeader: CardHeaderRecipe

package/dist/src/styled-system/recipes/card-header.mjs

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

package/dist/src/styled-system/recipes/card-title.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 CardTitleVariant {
-  
-}
-
-type CardTitleVariantMap = {
-  [key in keyof CardTitleVariant]: Array<CardTitleVariant[key]>
-}
-
-export type CardTitleVariantProps = {
-  [key in keyof CardTitleVariant]?: ConditionalValue<CardTitleVariant[key]> | undefined
-}
-
-export interface CardTitleRecipe {
-  __type: CardTitleVariantProps
-  (props?: CardTitleVariantProps): string
-  raw: (props?: CardTitleVariantProps) => CardTitleVariantProps
-  variantMap: CardTitleVariantMap
-  variantKeys: Array<keyof CardTitleVariant>
-  splitVariantProps<Props extends CardTitleVariantProps>(props: Props): [CardTitleVariantProps, Pretty<DistributiveOmit<Props, keyof CardTitleVariantProps>>]
-  getVariantProps: (props?: CardTitleVariantProps) => CardTitleVariantProps
-}
-
-/**
- * Styles for the CardTitle component
-
-
- */
-export declare const cardTitle: CardTitleRecipe

package/dist/src/styled-system/recipes/card-title.mjs

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

package/dist/src/styled-system/recipes/card.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 CardVariant {
-  
-}
-
-type CardVariantMap = {
-  [key in keyof CardVariant]: Array<CardVariant[key]>
-}
-
-export type CardVariantProps = {
-  [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]> | undefined
-}
-
-export interface CardRecipe {
-  __type: CardVariantProps
-  (props?: CardVariantProps): string
-  raw: (props?: CardVariantProps) => CardVariantProps
-  variantMap: CardVariantMap
-  variantKeys: Array<keyof CardVariant>
-  splitVariantProps<Props extends CardVariantProps>(props: Props): [CardVariantProps, Pretty<DistributiveOmit<Props, keyof CardVariantProps>>]
-  getVariantProps: (props?: CardVariantProps) => CardVariantProps
-}
-
-/**
- * Styles for the Card component
-
-
- */
-export declare const card: CardRecipe

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

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

package/dist/src/styled-system/recipes/checkbox.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 CheckboxVariant {
-  
-}
-
-type CheckboxVariantMap = {
-  [key in keyof CheckboxVariant]: Array<CheckboxVariant[key]>
-}
-
-export type CheckboxVariantProps = {
-  [key in keyof CheckboxVariant]?: ConditionalValue<CheckboxVariant[key]> | undefined
-}
-
-export interface CheckboxRecipe {
-  __type: CheckboxVariantProps
-  (props?: CheckboxVariantProps): Pretty<Record<"root" | "indicator", string>>
-  raw: (props?: CheckboxVariantProps) => CheckboxVariantProps
-  variantMap: CheckboxVariantMap
-  variantKeys: Array<keyof CheckboxVariant>
-  splitVariantProps<Props extends CheckboxVariantProps>(props: Props): [CheckboxVariantProps, Pretty<DistributiveOmit<Props, keyof CheckboxVariantProps>>]
-  getVariantProps: (props?: CheckboxVariantProps) => CheckboxVariantProps
-}
-
-/**
- * Styles for the Checkbox component
-
-
- */
-export declare const checkbox: CheckboxRecipe

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

@@ -1,36 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const checkboxDefaultVariants = {}
-const checkboxCompoundVariants = []
-
-const checkboxSlotNames = [
-  [
-    "root",
-    "checkbox__root"
-  ],
-  [
-    "indicator",
-    "checkbox__indicator"
-  ]
-]
-const checkboxSlotFns = /* @__PURE__ */ checkboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, checkboxDefaultVariants, getSlotCompoundVariant(checkboxCompoundVariants, slotName))])
-
-const checkboxFn = memo((props = {}) => {
-  return Object.fromEntries(checkboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const checkboxVariantKeys = []
-const getVariantProps = (variants) => ({ ...checkboxDefaultVariants, ...compact(variants) })
-
-export const checkbox = /* @__PURE__ */ Object.assign(checkboxFn, {
-  __recipe__: false,
-  __name__: 'checkbox',
-  raw: (props) => props,
-  variantKeys: checkboxVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, checkboxVariantKeys)
-  },
-  getVariantProps
-})

package/dist/src/styled-system/recipes/collapsible.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 CollapsibleVariant {
-  
-}
-
-type CollapsibleVariantMap = {
-  [key in keyof CollapsibleVariant]: Array<CollapsibleVariant[key]>
-}
-
-export type CollapsibleVariantProps = {
-  [key in keyof CollapsibleVariant]?: ConditionalValue<CollapsibleVariant[key]> | undefined
-}
-
-export interface CollapsibleRecipe {
-  __type: CollapsibleVariantProps
-  (props?: CollapsibleVariantProps): Pretty<Record<"root" | "trigger" | "content", string>>
-  raw: (props?: CollapsibleVariantProps) => CollapsibleVariantProps
-  variantMap: CollapsibleVariantMap
-  variantKeys: Array<keyof CollapsibleVariant>
-  splitVariantProps<Props extends CollapsibleVariantProps>(props: Props): [CollapsibleVariantProps, Pretty<DistributiveOmit<Props, keyof CollapsibleVariantProps>>]
-  getVariantProps: (props?: CollapsibleVariantProps) => CollapsibleVariantProps
-}
-
-/**
- * Styles for the Collapsible component
-
-
- */
-export declare const collapsible: CollapsibleRecipe

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

@@ -1,40 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const collapsibleDefaultVariants = {}
-const collapsibleCompoundVariants = []
-
-const collapsibleSlotNames = [
-  [
-    "root",
-    "collapsible__root"
-  ],
-  [
-    "trigger",
-    "collapsible__trigger"
-  ],
-  [
-    "content",
-    "collapsible__content"
-  ]
-]
-const collapsibleSlotFns = /* @__PURE__ */ collapsibleSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, collapsibleDefaultVariants, getSlotCompoundVariant(collapsibleCompoundVariants, slotName))])
-
-const collapsibleFn = memo((props = {}) => {
-  return Object.fromEntries(collapsibleSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const collapsibleVariantKeys = []
-const getVariantProps = (variants) => ({ ...collapsibleDefaultVariants, ...compact(variants) })
-
-export const collapsible = /* @__PURE__ */ Object.assign(collapsibleFn, {
-  __recipe__: false,
-  __name__: 'collapsible',
-  raw: (props) => props,
-  variantKeys: collapsibleVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, collapsibleVariantKeys)
-  },
-  getVariantProps
-})

package/dist/src/styled-system/recipes/command-dialog.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 CommandDialogVariant {
-  
-}
-
-type CommandDialogVariantMap = {
-  [key in keyof CommandDialogVariant]: Array<CommandDialogVariant[key]>
-}
-
-export type CommandDialogVariantProps = {
-  [key in keyof CommandDialogVariant]?: ConditionalValue<CommandDialogVariant[key]> | undefined
-}
-
-export interface CommandDialogRecipe {
-  __type: CommandDialogVariantProps
-  (props?: CommandDialogVariantProps): Pretty<Record<"content" | "command", string>>
-  raw: (props?: CommandDialogVariantProps) => CommandDialogVariantProps
-  variantMap: CommandDialogVariantMap
-  variantKeys: Array<keyof CommandDialogVariant>
-  splitVariantProps<Props extends CommandDialogVariantProps>(props: Props): [CommandDialogVariantProps, Pretty<DistributiveOmit<Props, keyof CommandDialogVariantProps>>]
-  getVariantProps: (props?: CommandDialogVariantProps) => CommandDialogVariantProps
-}
-
-/**
- * Styles for the CommandDialog component
-
-
- */
-export declare const commandDialog: CommandDialogRecipe

package/dist/src/styled-system/recipes/command-dialog.mjs

@@ -1,36 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const commandDialogDefaultVariants = {}
-const commandDialogCompoundVariants = []
-
-const commandDialogSlotNames = [
-  [
-    "content",
-    "command-dialog__content"
-  ],
-  [
-    "command",
-    "command-dialog__command"
-  ]
-]
-const commandDialogSlotFns = /* @__PURE__ */ commandDialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, commandDialogDefaultVariants, getSlotCompoundVariant(commandDialogCompoundVariants, slotName))])
-
-const commandDialogFn = memo((props = {}) => {
-  return Object.fromEntries(commandDialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const commandDialogVariantKeys = []
-const getVariantProps = (variants) => ({ ...commandDialogDefaultVariants, ...compact(variants) })
-
-export const commandDialog = /* @__PURE__ */ Object.assign(commandDialogFn, {
-  __recipe__: false,
-  __name__: 'commandDialog',
-  raw: (props) => props,
-  variantKeys: commandDialogVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, commandDialogVariantKeys)
-  },
-  getVariantProps
-})

package/dist/src/styled-system/recipes/command.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 CommandVariant {
-  
-}
-
-type CommandVariantMap = {
-  [key in keyof CommandVariant]: Array<CommandVariant[key]>
-}
-
-export type CommandVariantProps = {
-  [key in keyof CommandVariant]?: ConditionalValue<CommandVariant[key]> | undefined
-}
-
-export interface CommandRecipe {
-  __type: CommandVariantProps
-  (props?: CommandVariantProps): Pretty<Record<"root" | "inputWrapper" | "inputSearch" | "input" | "list" | "empty" | "group" | "separator" | "item" | "shortcut", string>>
-  raw: (props?: CommandVariantProps) => CommandVariantProps
-  variantMap: CommandVariantMap
-  variantKeys: Array<keyof CommandVariant>
-  splitVariantProps<Props extends CommandVariantProps>(props: Props): [CommandVariantProps, Pretty<DistributiveOmit<Props, keyof CommandVariantProps>>]
-  getVariantProps: (props?: CommandVariantProps) => CommandVariantProps
-}
-
-/**
- * Styles for the Command component
-
-
- */
-export declare const command: CommandRecipe

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

@@ -1,68 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const commandDefaultVariants = {}
-const commandCompoundVariants = []
-
-const commandSlotNames = [
-  [
-    "root",
-    "command__root"
-  ],
-  [
-    "inputWrapper",
-    "command__inputWrapper"
-  ],
-  [
-    "inputSearch",
-    "command__inputSearch"
-  ],
-  [
-    "input",
-    "command__input"
-  ],
-  [
-    "list",
-    "command__list"
-  ],
-  [
-    "empty",
-    "command__empty"
-  ],
-  [
-    "group",
-    "command__group"
-  ],
-  [
-    "separator",
-    "command__separator"
-  ],
-  [
-    "item",
-    "command__item"
-  ],
-  [
-    "shortcut",
-    "command__shortcut"
-  ]
-]
-const commandSlotFns = /* @__PURE__ */ commandSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, commandDefaultVariants, getSlotCompoundVariant(commandCompoundVariants, slotName))])
-
-const commandFn = memo((props = {}) => {
-  return Object.fromEntries(commandSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const commandVariantKeys = []
-const getVariantProps = (variants) => ({ ...commandDefaultVariants, ...compact(variants) })
-
-export const command = /* @__PURE__ */ Object.assign(commandFn, {
-  __recipe__: false,
-  __name__: 'command',
-  raw: (props) => props,
-  variantKeys: commandVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, commandVariantKeys)
-  },
-  getVariantProps
-})

package/dist/src/styled-system/recipes/context-menu.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 ContextMenuVariant {
-  /**
- * @default false
- */
-inset: boolean
-}
-
-type ContextMenuVariantMap = {
-  [key in keyof ContextMenuVariant]: Array<ContextMenuVariant[key]>
-}
-
-export type ContextMenuVariantProps = {
-  [key in keyof ContextMenuVariant]?: ConditionalValue<ContextMenuVariant[key]> | undefined
-}
-
-export interface ContextMenuRecipe {
-  __type: ContextMenuVariantProps
-  (props?: ContextMenuVariantProps): Pretty<Record<"root" | "trigger" | "group" | "portal" | "sub" | "radioGroup" | "subTrigger" | "subContent" | "content" | "item" | "checkboxItem" | "radioItem" | "label" | "separator" | "shortcut" | "itemIndicator", string>>
-  raw: (props?: ContextMenuVariantProps) => ContextMenuVariantProps
-  variantMap: ContextMenuVariantMap
-  variantKeys: Array<keyof ContextMenuVariant>
-  splitVariantProps<Props extends ContextMenuVariantProps>(props: Props): [ContextMenuVariantProps, Pretty<DistributiveOmit<Props, keyof ContextMenuVariantProps>>]
-  getVariantProps: (props?: ContextMenuVariantProps) => ContextMenuVariantProps
-}
-
-/**
- * Styles for the ContextMenu component
-
-
- */
-export declare const contextMenu: ContextMenuRecipe

package/dist/src/styled-system/recipes/context-menu.mjs

@@ -1,100 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
-import { createRecipe } from './create-recipe.mjs';
-
-const contextMenuDefaultVariants = {
-  "inset": false
-}
-const contextMenuCompoundVariants = []
-
-const contextMenuSlotNames = [
-  [
-    "root",
-    "contextMenu__root"
-  ],
-  [
-    "trigger",
-    "contextMenu__trigger"
-  ],
-  [
-    "group",
-    "contextMenu__group"
-  ],
-  [
-    "portal",
-    "contextMenu__portal"
-  ],
-  [
-    "sub",
-    "contextMenu__sub"
-  ],
-  [
-    "radioGroup",
-    "contextMenu__radioGroup"
-  ],
-  [
-    "subTrigger",
-    "contextMenu__subTrigger"
-  ],
-  [
-    "subContent",
-    "contextMenu__subContent"
-  ],
-  [
-    "content",
-    "contextMenu__content"
-  ],
-  [
-    "item",
-    "contextMenu__item"
-  ],
-  [
-    "checkboxItem",
-    "contextMenu__checkboxItem"
-  ],
-  [
-    "radioItem",
-    "contextMenu__radioItem"
-  ],
-  [
-    "label",
-    "contextMenu__label"
-  ],
-  [
-    "separator",
-    "contextMenu__separator"
-  ],
-  [
-    "shortcut",
-    "contextMenu__shortcut"
-  ],
-  [
-    "itemIndicator",
-    "contextMenu__itemIndicator"
-  ]
-]
-const contextMenuSlotFns = /* @__PURE__ */ contextMenuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, contextMenuDefaultVariants, getSlotCompoundVariant(contextMenuCompoundVariants, slotName))])
-
-const contextMenuFn = memo((props = {}) => {
-  return Object.fromEntries(contextMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const contextMenuVariantKeys = [
-  "inset"
-]
-const getVariantProps = (variants) => ({ ...contextMenuDefaultVariants, ...compact(variants) })
-
-export const contextMenu = /* @__PURE__ */ Object.assign(contextMenuFn, {
-  __recipe__: false,
-  __name__: 'contextMenu',
-  raw: (props) => props,
-  variantKeys: contextMenuVariantKeys,
-  variantMap: {
-  "inset": [
-    "true"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, contextMenuVariantKeys)
-  },
-  getVariantProps
-})