@luxonis/depthai-pipeline-lib 1.4.8

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

@@ -0,0 +1,118 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const calendarDefaultVariants = {}
+const calendarCompoundVariants = []
+
+const calendarSlotNames = [
+  [
+    "root",
+    "calendar__root"
+  ],
+  [
+    "months",
+    "calendar__months"
+  ],
+  [
+    "month",
+    "calendar__month"
+  ],
+  [
+    "caption",
+    "calendar__caption"
+  ],
+  [
+    "caption_label",
+    "calendar__caption_label"
+  ],
+  [
+    "nav",
+    "calendar__nav"
+  ],
+  [
+    "nav_button",
+    "calendar__nav_button"
+  ],
+  [
+    "nav_button_previous",
+    "calendar__nav_button_previous"
+  ],
+  [
+    "nav_button_next",
+    "calendar__nav_button_next"
+  ],
+  [
+    "table",
+    "calendar__table"
+  ],
+  [
+    "head_row",
+    "calendar__head_row"
+  ],
+  [
+    "head_cell",
+    "calendar__head_cell"
+  ],
+  [
+    "row",
+    "calendar__row"
+  ],
+  [
+    "cell",
+    "calendar__cell"
+  ],
+  [
+    "day",
+    "calendar__day"
+  ],
+  [
+    "day_selected",
+    "calendar__day_selected"
+  ],
+  [
+    "day_today",
+    "calendar__day_today"
+  ],
+  [
+    "day_outside",
+    "calendar__day_outside"
+  ],
+  [
+    "day_disabled",
+    "calendar__day_disabled"
+  ],
+  [
+    "day_range_start",
+    "calendar__day_range_start"
+  ],
+  [
+    "day_range_middle",
+    "calendar__day_range_middle"
+  ],
+  [
+    "day_range_end",
+    "calendar__day_range_end"
+  ],
+  [
+    "day_hidden",
+    "calendar__day_hidden"
+  ]
+]
+const calendarSlotFns = /* @__PURE__ */ calendarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, calendarDefaultVariants, getSlotCompoundVariant(calendarCompoundVariants, slotName))])
+
+const calendarFn = (props = {}) => {
+  return Object.fromEntries(calendarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const calendarVariantKeys = []
+
+export const calendar = /* @__PURE__ */ Object.assign(calendarFn, {
+  __recipe__: false,
+  __name__: 'calendar',
+  raw: (props) => props,
+  variantKeys: calendarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, calendarVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/card-content.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 CardContentVariant {
+  
+}
+
+type CardContentVariantMap = {
+  [key in keyof CardContentVariant]: Array<CardContentVariant[key]>
+}
+
+export type CardContentVariantProps = {
+  [key in keyof CardContentVariant]?: ConditionalValue<CardContentVariant[key]>
+}
+
+export interface CardContentRecipe {
+  __type: CardContentVariantProps
+  (props?: CardContentVariantProps): string
+  raw: (props?: CardContentVariantProps) => CardContentVariantProps
+  variantMap: CardContentVariantMap
+  variantKeys: Array<keyof CardContentVariant>
+  splitVariantProps<Props extends CardContentVariantProps>(props: Props): [CardContentVariantProps, Pretty<DistributiveOmit<Props, keyof CardContentVariantProps>>]
+}
+
+/** Styles for the CardContent component */
+export declare const cardContent: CardContentRecipe

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

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

package/dist/src/styled-system/recipes/card-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 CardDescriptionVariant {
+  
+}
+
+type CardDescriptionVariantMap = {
+  [key in keyof CardDescriptionVariant]: Array<CardDescriptionVariant[key]>
+}
+
+export type CardDescriptionVariantProps = {
+  [key in keyof CardDescriptionVariant]?: ConditionalValue<CardDescriptionVariant[key]>
+}
+
+export interface CardDescriptionRecipe {
+  __type: CardDescriptionVariantProps
+  (props?: CardDescriptionVariantProps): string
+  raw: (props?: CardDescriptionVariantProps) => CardDescriptionVariantProps
+  variantMap: CardDescriptionVariantMap
+  variantKeys: Array<keyof CardDescriptionVariant>
+  splitVariantProps<Props extends CardDescriptionVariantProps>(props: Props): [CardDescriptionVariantProps, Pretty<DistributiveOmit<Props, keyof CardDescriptionVariantProps>>]
+}
+
+/** Styles for the CardDescription component */
+export declare const cardDescription: CardDescriptionRecipe

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

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

package/dist/src/styled-system/recipes/card-footer.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 CardFooterVariant {
+  
+}
+
+type CardFooterVariantMap = {
+  [key in keyof CardFooterVariant]: Array<CardFooterVariant[key]>
+}
+
+export type CardFooterVariantProps = {
+  [key in keyof CardFooterVariant]?: ConditionalValue<CardFooterVariant[key]>
+}
+
+export interface CardFooterRecipe {
+  __type: CardFooterVariantProps
+  (props?: CardFooterVariantProps): string
+  raw: (props?: CardFooterVariantProps) => CardFooterVariantProps
+  variantMap: CardFooterVariantMap
+  variantKeys: Array<keyof CardFooterVariant>
+  splitVariantProps<Props extends CardFooterVariantProps>(props: Props): [CardFooterVariantProps, Pretty<DistributiveOmit<Props, keyof CardFooterVariantProps>>]
+}
+
+/** Styles for the CardFooter component */
+export declare const cardFooter: CardFooterRecipe

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

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

package/dist/src/styled-system/recipes/card-header.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 CardHeaderVariant {
+  
+}
+
+type CardHeaderVariantMap = {
+  [key in keyof CardHeaderVariant]: Array<CardHeaderVariant[key]>
+}
+
+export type CardHeaderVariantProps = {
+  [key in keyof CardHeaderVariant]?: ConditionalValue<CardHeaderVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the CardHeader component */
+export declare const cardHeader: CardHeaderRecipe

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

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

package/dist/src/styled-system/recipes/card-title.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 CardTitleVariant {
+  
+}
+
+type CardTitleVariantMap = {
+  [key in keyof CardTitleVariant]: Array<CardTitleVariant[key]>
+}
+
+export type CardTitleVariantProps = {
+  [key in keyof CardTitleVariant]?: ConditionalValue<CardTitleVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the CardTitle component */
+export declare const cardTitle: CardTitleRecipe

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

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

package/dist/src/styled-system/recipes/card.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 CardVariant {
+  
+}
+
+type CardVariantMap = {
+  [key in keyof CardVariant]: Array<CardVariant[key]>
+}
+
+export type CardVariantProps = {
+  [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the Card component */
+export declare const card: CardRecipe

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

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

package/dist/src/styled-system/recipes/checkbox.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 CheckboxVariant {
+  
+}
+
+type CheckboxVariantMap = {
+  [key in keyof CheckboxVariant]: Array<CheckboxVariant[key]>
+}
+
+export type CheckboxVariantProps = {
+  [key in keyof CheckboxVariant]?: ConditionalValue<CheckboxVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the Checkbox component */
+export declare const checkbox: CheckboxRecipe

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

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

package/dist/src/styled-system/recipes/collapsible.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 CollapsibleVariant {
+  
+}
+
+type CollapsibleVariantMap = {
+  [key in keyof CollapsibleVariant]: Array<CollapsibleVariant[key]>
+}
+
+export type CollapsibleVariantProps = {
+  [key in keyof CollapsibleVariant]?: ConditionalValue<CollapsibleVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the Collapsible component */
+export declare const collapsible: CollapsibleRecipe

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

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

package/dist/src/styled-system/recipes/command-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 CommandDialogVariant {
+  
+}
+
+type CommandDialogVariantMap = {
+  [key in keyof CommandDialogVariant]: Array<CommandDialogVariant[key]>
+}
+
+export type CommandDialogVariantProps = {
+  [key in keyof CommandDialogVariant]?: ConditionalValue<CommandDialogVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the CommandDialog component */
+export declare const commandDialog: CommandDialogRecipe

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

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

package/dist/src/styled-system/recipes/command.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 CommandVariant {
+  
+}
+
+type CommandVariantMap = {
+  [key in keyof CommandVariant]: Array<CommandVariant[key]>
+}
+
+export type CommandVariantProps = {
+  [key in keyof CommandVariant]?: ConditionalValue<CommandVariant[key]>
+}
+
+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>>]
+}
+
+/** Styles for the Command component */
+export declare const command: CommandRecipe