@luxonis/depthai-pipeline-lib 1.4.8

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

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } 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 = (props = {}) => {
+  return Object.fromEntries(commandSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const commandVariantKeys = []
+
+export const command = /* @__PURE__ */ Object.assign(commandFn, {
+  __recipe__: false,
+  __name__: 'command',
+  raw: (props) => props,
+  variantKeys: commandVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, commandVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/context-menu.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 ContextMenuVariant {
+  inset: boolean
+}
+
+type ContextMenuVariantMap = {
+  [key in keyof ContextMenuVariant]: Array<ContextMenuVariant[key]>
+}
+
+export type ContextMenuVariantProps = {
+  [key in keyof ContextMenuVariant]?: ConditionalValue<ContextMenuVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the ContextMenu component */
+export declare const contextMenu: ContextMenuRecipe

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

@@ -0,0 +1,98 @@
+import { splitProps, getSlotCompoundVariant } 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 = (props = {}) => {
+  return Object.fromEntries(contextMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const contextMenuVariantKeys = [
+  "inset"
+]
+
+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)
+  },
+})

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

@@ -0,0 +1 @@
+/* eslint-disable */

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

@@ -0,0 +1,50 @@
+import { css } from '../css/css.mjs';
+import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.mjs';
+import { cx } from '../css/cx.mjs';
+import { compact, createCss, withoutSpace } from '../helpers.mjs';
+
+export const createRecipe = (name, defaultVariants, compoundVariants) => {
+ const getRecipeStyles = (variants) => {
+   return {
+     [name]: '__ignore__',
+     ...defaultVariants,
+     ...compact(variants),
+   };
+ };
+
+  const recipeFn = (variants, withCompoundVariants = true) => {
+   const transform = (prop, value) => {
+     assertCompoundVariant(name, compoundVariants, variants, prop)
+
+      if (value === '__ignore__') {
+        return { className: name }
+      }
+
+      value = withoutSpace(value)
+      return { className: `${name}--${prop}_${value}` }
+   }
+
+   const recipeCss = createCss({
+     
+     utility: {
+       
+       transform,
+     }
+   })
+
+   const recipeStyles = getRecipeStyles(variants)
+
+   if (withCompoundVariants) {
+     const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles)
+     return cx(recipeCss(recipeStyles), css(compoundVariantStyles))
+   }
+
+   return recipeCss(recipeStyles)
+  }
+
+   return Object.assign(recipeFn, {
+     __getCompoundVariantCss__: (variants) => {
+       return getCompoundVariantCss(compoundVariants, getRecipeStyles(variants));
+     },
+   })
+}

package/dist/src/styled-system/recipes/dialog.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 DialogVariant {
+  
+}
+
+type DialogVariantMap = {
+  [key in keyof DialogVariant]: Array<DialogVariant[key]>
+}
+
+export type DialogVariantProps = {
+  [key in keyof DialogVariant]?: ConditionalValue<DialogVariant[key]>
+}
+
+export interface DialogRecipe {
+  __type: DialogVariantProps
+  (props?: DialogVariantProps): Pretty<Record<"root" | "trigger" | "portal" | "overlay" | "close" | "content" | "header" | "footer" | "title" | "description", string>>
+  raw: (props?: DialogVariantProps) => DialogVariantProps
+  variantMap: DialogVariantMap
+  variantKeys: Array<keyof DialogVariant>
+  splitVariantProps<Props extends DialogVariantProps>(props: Props): [DialogVariantProps, Pretty<DistributiveOmit<Props, keyof DialogVariantProps>>]
+}
+
+/** Styles for the Dialog component */
+export declare const dialog: DialogRecipe

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

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dialogDefaultVariants = {}
+const dialogCompoundVariants = []
+
+const dialogSlotNames = [
+  [
+    "root",
+    "dialog__root"
+  ],
+  [
+    "trigger",
+    "dialog__trigger"
+  ],
+  [
+    "portal",
+    "dialog__portal"
+  ],
+  [
+    "overlay",
+    "dialog__overlay"
+  ],
+  [
+    "close",
+    "dialog__close"
+  ],
+  [
+    "content",
+    "dialog__content"
+  ],
+  [
+    "header",
+    "dialog__header"
+  ],
+  [
+    "footer",
+    "dialog__footer"
+  ],
+  [
+    "title",
+    "dialog__title"
+  ],
+  [
+    "description",
+    "dialog__description"
+  ]
+]
+const dialogSlotFns = /* @__PURE__ */ dialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dialogDefaultVariants, getSlotCompoundVariant(dialogCompoundVariants, slotName))])
+
+const dialogFn = (props = {}) => {
+  return Object.fromEntries(dialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dialogVariantKeys = []
+
+export const dialog = /* @__PURE__ */ Object.assign(dialogFn, {
+  __recipe__: false,
+  __name__: 'dialog',
+  raw: (props) => props,
+  variantKeys: dialogVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dialogVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/dropdown-menu.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 DropdownMenuVariant {
+  
+}
+
+type DropdownMenuVariantMap = {
+  [key in keyof DropdownMenuVariant]: Array<DropdownMenuVariant[key]>
+}
+
+export type DropdownMenuVariantProps = {
+  [key in keyof DropdownMenuVariant]?: ConditionalValue<DropdownMenuVariant[key]>
+}
+
+export interface DropdownMenuRecipe {
+  __type: DropdownMenuVariantProps
+  (props?: DropdownMenuVariantProps): Pretty<Record<"root" | "trigger" | "group" | "portal" | "sub" | "radioGroup" | "subTrigger" | "subContent" | "content" | "item" | "itemIndicator" | "checkboxItem" | "radioItem" | "label" | "separator" | "shortcut", string>>
+  raw: (props?: DropdownMenuVariantProps) => DropdownMenuVariantProps
+  variantMap: DropdownMenuVariantMap
+  variantKeys: Array<keyof DropdownMenuVariant>
+  splitVariantProps<Props extends DropdownMenuVariantProps>(props: Props): [DropdownMenuVariantProps, Pretty<DistributiveOmit<Props, keyof DropdownMenuVariantProps>>]
+}
+
+/** Styles for the DropdownMenu component */
+export declare const dropdownMenu: DropdownMenuRecipe

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

@@ -0,0 +1,90 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dropdownMenuDefaultVariants = {}
+const dropdownMenuCompoundVariants = []
+
+const dropdownMenuSlotNames = [
+  [
+    "root",
+    "dropdownMenu__root"
+  ],
+  [
+    "trigger",
+    "dropdownMenu__trigger"
+  ],
+  [
+    "group",
+    "dropdownMenu__group"
+  ],
+  [
+    "portal",
+    "dropdownMenu__portal"
+  ],
+  [
+    "sub",
+    "dropdownMenu__sub"
+  ],
+  [
+    "radioGroup",
+    "dropdownMenu__radioGroup"
+  ],
+  [
+    "subTrigger",
+    "dropdownMenu__subTrigger"
+  ],
+  [
+    "subContent",
+    "dropdownMenu__subContent"
+  ],
+  [
+    "content",
+    "dropdownMenu__content"
+  ],
+  [
+    "item",
+    "dropdownMenu__item"
+  ],
+  [
+    "itemIndicator",
+    "dropdownMenu__itemIndicator"
+  ],
+  [
+    "checkboxItem",
+    "dropdownMenu__checkboxItem"
+  ],
+  [
+    "radioItem",
+    "dropdownMenu__radioItem"
+  ],
+  [
+    "label",
+    "dropdownMenu__label"
+  ],
+  [
+    "separator",
+    "dropdownMenu__separator"
+  ],
+  [
+    "shortcut",
+    "dropdownMenu__shortcut"
+  ]
+]
+const dropdownMenuSlotFns = /* @__PURE__ */ dropdownMenuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuDefaultVariants, getSlotCompoundVariant(dropdownMenuCompoundVariants, slotName))])
+
+const dropdownMenuFn = (props = {}) => {
+  return Object.fromEntries(dropdownMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dropdownMenuVariantKeys = []
+
+export const dropdownMenu = /* @__PURE__ */ Object.assign(dropdownMenuFn, {
+  __recipe__: false,
+  __name__: 'dropdownMenu',
+  raw: (props) => props,
+  variantKeys: dropdownMenuVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dropdownMenuVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/form-control.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 FormControlVariant {
+  
+}
+
+type FormControlVariantMap = {
+  [key in keyof FormControlVariant]: Array<FormControlVariant[key]>
+}
+
+export type FormControlVariantProps = {
+  [key in keyof FormControlVariant]?: ConditionalValue<FormControlVariant[key]>
+}
+
+export interface FormControlRecipe {
+  __type: FormControlVariantProps
+  (props?: FormControlVariantProps): string
+  raw: (props?: FormControlVariantProps) => FormControlVariantProps
+  variantMap: FormControlVariantMap
+  variantKeys: Array<keyof FormControlVariant>
+  splitVariantProps<Props extends FormControlVariantProps>(props: Props): [FormControlVariantProps, Pretty<DistributiveOmit<Props, keyof FormControlVariantProps>>]
+}
+
+/** Styles for the FormControl component */
+export declare const formControl: FormControlRecipe

package/dist/src/styled-system/recipes/form-control.mjs

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

package/dist/src/styled-system/recipes/form-description.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 FormDescriptionVariant {
+  
+}
+
+type FormDescriptionVariantMap = {
+  [key in keyof FormDescriptionVariant]: Array<FormDescriptionVariant[key]>
+}
+
+export type FormDescriptionVariantProps = {
+  [key in keyof FormDescriptionVariant]?: ConditionalValue<FormDescriptionVariant[key]>
+}
+
+export interface FormDescriptionRecipe {
+  __type: FormDescriptionVariantProps
+  (props?: FormDescriptionVariantProps): string
+  raw: (props?: FormDescriptionVariantProps) => FormDescriptionVariantProps
+  variantMap: FormDescriptionVariantMap
+  variantKeys: Array<keyof FormDescriptionVariant>
+  splitVariantProps<Props extends FormDescriptionVariantProps>(props: Props): [FormDescriptionVariantProps, Pretty<DistributiveOmit<Props, keyof FormDescriptionVariantProps>>]
+}
+
+/** Styles for the FormDescription component */
+export declare const formDescription: FormDescriptionRecipe

package/dist/src/styled-system/recipes/form-description.mjs

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

package/dist/src/styled-system/recipes/form-item.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 FormItemVariant {
+  
+}
+
+type FormItemVariantMap = {
+  [key in keyof FormItemVariant]: Array<FormItemVariant[key]>
+}
+
+export type FormItemVariantProps = {
+  [key in keyof FormItemVariant]?: ConditionalValue<FormItemVariant[key]>
+}
+
+export interface FormItemRecipe {
+  __type: FormItemVariantProps
+  (props?: FormItemVariantProps): string
+  raw: (props?: FormItemVariantProps) => FormItemVariantProps
+  variantMap: FormItemVariantMap
+  variantKeys: Array<keyof FormItemVariant>
+  splitVariantProps<Props extends FormItemVariantProps>(props: Props): [FormItemVariantProps, Pretty<DistributiveOmit<Props, keyof FormItemVariantProps>>]
+}
+
+/** Styles for the FormItem component */
+export declare const formItem: FormItemRecipe

package/dist/src/styled-system/recipes/form-item.mjs

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

package/dist/src/styled-system/recipes/form-label.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 FormLabelVariant {
+  
+}
+
+type FormLabelVariantMap = {
+  [key in keyof FormLabelVariant]: Array<FormLabelVariant[key]>
+}
+
+export type FormLabelVariantProps = {
+  [key in keyof FormLabelVariant]?: ConditionalValue<FormLabelVariant[key]>
+}
+
+export interface FormLabelRecipe {
+  __type: FormLabelVariantProps
+  (props?: FormLabelVariantProps): string
+  raw: (props?: FormLabelVariantProps) => FormLabelVariantProps
+  variantMap: FormLabelVariantMap
+  variantKeys: Array<keyof FormLabelVariant>
+  splitVariantProps<Props extends FormLabelVariantProps>(props: Props): [FormLabelVariantProps, Pretty<DistributiveOmit<Props, keyof FormLabelVariantProps>>]
+}
+
+/** Styles for the FormLabel component */
+export declare const formLabel: FormLabelRecipe

package/dist/src/styled-system/recipes/form-label.mjs

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

package/dist/src/styled-system/recipes/form-message.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 FormMessageVariant {
+  
+}
+
+type FormMessageVariantMap = {
+  [key in keyof FormMessageVariant]: Array<FormMessageVariant[key]>
+}
+
+export type FormMessageVariantProps = {
+  [key in keyof FormMessageVariant]?: ConditionalValue<FormMessageVariant[key]>
+}
+
+export interface FormMessageRecipe {
+  __type: FormMessageVariantProps
+  (props?: FormMessageVariantProps): string
+  raw: (props?: FormMessageVariantProps) => FormMessageVariantProps
+  variantMap: FormMessageVariantMap
+  variantKeys: Array<keyof FormMessageVariant>
+  splitVariantProps<Props extends FormMessageVariantProps>(props: Props): [FormMessageVariantProps, Pretty<DistributiveOmit<Props, keyof FormMessageVariantProps>>]
+}
+
+/** Styles for the FormMessage component */
+export declare const formMessage: FormMessageRecipe