@luxonis/depthai-pipeline-lib 1.4.8

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

@@ -0,0 +1,29 @@
+/* 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 ToggleVariant {
+  variant: "default" | "outline"
+size: "default" | "sm" | "lg"
+}
+
+type ToggleVariantMap = {
+  [key in keyof ToggleVariant]: Array<ToggleVariant[key]>
+}
+
+export type ToggleVariantProps = {
+  [key in keyof ToggleVariant]?: ConditionalValue<ToggleVariant[key]>
+}
+
+export interface ToggleRecipe {
+  __type: ToggleVariantProps
+  (props?: ToggleVariantProps): string
+  raw: (props?: ToggleVariantProps) => ToggleVariantProps
+  variantMap: ToggleVariantMap
+  variantKeys: Array<keyof ToggleVariant>
+  splitVariantProps<Props extends ToggleVariantProps>(props: Props): [ToggleVariantProps, Pretty<DistributiveOmit<Props, keyof ToggleVariantProps>>]
+}
+
+/** Styles for the Toggle component */
+export declare const toggle: ToggleRecipe

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

@@ -0,0 +1,32 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toggleFn = /* @__PURE__ */ createRecipe('toggle', {
+  "variant": "default",
+  "size": "default"
+}, [])
+
+const toggleVariantMap = {
+  "variant": [
+    "default",
+    "outline"
+  ],
+  "size": [
+    "default",
+    "sm",
+    "lg"
+  ]
+}
+
+const toggleVariantKeys = Object.keys(toggleVariantMap)
+
+export const toggle = /* @__PURE__ */ Object.assign(toggleFn, {
+  __recipe__: true,
+  __name__: 'toggle',
+  raw: (props) => props,
+  variantKeys: toggleVariantKeys,
+  variantMap: toggleVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, toggleVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/tooltip.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 TooltipVariant {
+  
+}
+
+type TooltipVariantMap = {
+  [key in keyof TooltipVariant]: Array<TooltipVariant[key]>
+}
+
+export type TooltipVariantProps = {
+  [key in keyof TooltipVariant]?: ConditionalValue<TooltipVariant[key]>
+}
+
+export interface TooltipRecipe {
+  __type: TooltipVariantProps
+  (props?: TooltipVariantProps): Pretty<Record<"root" | "trigger" | "content", string>>
+  raw: (props?: TooltipVariantProps) => TooltipVariantProps
+  variantMap: TooltipVariantMap
+  variantKeys: Array<keyof TooltipVariant>
+  splitVariantProps<Props extends TooltipVariantProps>(props: Props): [TooltipVariantProps, Pretty<DistributiveOmit<Props, keyof TooltipVariantProps>>]
+}
+
+/** Styles for the Tooltip component */
+export declare const tooltip: TooltipRecipe

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

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tooltipDefaultVariants = {}
+const tooltipCompoundVariants = []
+
+const tooltipSlotNames = [
+  [
+    "root",
+    "tooltip__root"
+  ],
+  [
+    "trigger",
+    "tooltip__trigger"
+  ],
+  [
+    "content",
+    "tooltip__content"
+  ]
+]
+const tooltipSlotFns = /* @__PURE__ */ tooltipSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tooltipDefaultVariants, getSlotCompoundVariant(tooltipCompoundVariants, slotName))])
+
+const tooltipFn = (props = {}) => {
+  return Object.fromEntries(tooltipSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const tooltipVariantKeys = []
+
+export const tooltip = /* @__PURE__ */ Object.assign(tooltipFn, {
+  __recipe__: false,
+  __name__: 'tooltip',
+  raw: (props) => props,
+  variantKeys: tooltipVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tooltipVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/typography-table-container.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 TypographyTableContainerVariant {
+  
+}
+
+type TypographyTableContainerVariantMap = {
+  [key in keyof TypographyTableContainerVariant]: Array<TypographyTableContainerVariant[key]>
+}
+
+export type TypographyTableContainerVariantProps = {
+  [key in keyof TypographyTableContainerVariant]?: ConditionalValue<TypographyTableContainerVariant[key]>
+}
+
+export interface TypographyTableContainerRecipe {
+  __type: TypographyTableContainerVariantProps
+  (props?: TypographyTableContainerVariantProps): string
+  raw: (props?: TypographyTableContainerVariantProps) => TypographyTableContainerVariantProps
+  variantMap: TypographyTableContainerVariantMap
+  variantKeys: Array<keyof TypographyTableContainerVariant>
+  splitVariantProps<Props extends TypographyTableContainerVariantProps>(props: Props): [TypographyTableContainerVariantProps, Pretty<DistributiveOmit<Props, keyof TypographyTableContainerVariantProps>>]
+}
+
+/** Typography - table container style */
+export declare const typographyTableContainer: TypographyTableContainerRecipe

package/dist/src/styled-system/recipes/typography-table-container.mjs

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

package/dist/src/styled-system/recipes/typography-table.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 TypographyTableVariant {
+  
+}
+
+type TypographyTableVariantMap = {
+  [key in keyof TypographyTableVariant]: Array<TypographyTableVariant[key]>
+}
+
+export type TypographyTableVariantProps = {
+  [key in keyof TypographyTableVariant]?: ConditionalValue<TypographyTableVariant[key]>
+}
+
+export interface TypographyTableRecipe {
+  __type: TypographyTableVariantProps
+  (props?: TypographyTableVariantProps): string
+  raw: (props?: TypographyTableVariantProps) => TypographyTableVariantProps
+  variantMap: TypographyTableVariantMap
+  variantKeys: Array<keyof TypographyTableVariant>
+  splitVariantProps<Props extends TypographyTableVariantProps>(props: Props): [TypographyTableVariantProps, Pretty<DistributiveOmit<Props, keyof TypographyTableVariantProps>>]
+}
+
+/** Typography - table style */
+export declare const typographyTable: TypographyTableRecipe

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

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

package/dist/src/styled-system/reset.css

@@ -0,0 +1,206 @@
+@layer reset {
+  * {
+    margin: 0;
+    padding: 0;
+    font: inherit;
+  }
+
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+    border-width: 0;
+    border-style: solid;
+    border-color: var(--global-color-border, currentColor);
+  }
+
+  html {
+    line-height: 1.5;
+    --font-fallback: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
+      'Helvetica Neue', Arial, 'Noto Sans', sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol',
+      'Noto Color Emoji';
+    -webkit-text-size-adjust: 100%;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    -moz-tab-size: 4;
+    tab-size: 4;
+    font-family: var(--global-font-body, var(--font-fallback));
+  }
+
+  hr {
+    height: 0;
+    color: inherit;
+    border-top-width: 1px;
+  }
+
+  body {
+    height: 100%;
+    line-height: inherit;
+  }
+
+  img {
+    border-style: none;
+  }
+
+  img,
+  svg,
+  video,
+  canvas,
+  audio,
+  iframe,
+  embed,
+  object {
+    display: block;
+    vertical-align: middle;
+  }
+
+  img,
+  video {
+    max-width: 100%;
+    height: auto;
+  }
+
+  p,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    overflow-wrap: break-word;
+  }
+
+  ol,
+  ul {
+    list-style: none;
+  }
+
+  code,
+  kbd,
+  pre,
+  samp {
+    font-size: 1em;
+  }
+
+  button,
+  [type='button'],
+  [type='reset'],
+  [type='submit'] {
+    -webkit-appearance: button;
+    background-color: transparent;
+    background-image: none;
+  }
+
+  button,
+  select {
+    text-transform: none;
+  }
+
+  table {
+    text-indent: 0;
+    border-color: inherit;
+    border-collapse: collapse;
+  }
+
+  input::placeholder,
+  textarea::placeholder {
+    opacity: 1;
+    color: var(--global-color-placeholder, #9ca3af);
+  }
+
+  textarea {
+    resize: vertical;
+  }
+
+  summary {
+    display: list-item;
+  }
+
+  small {
+    font-size: 80%;
+  }
+
+  sub,
+  sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+  }
+
+  sub {
+    bottom: -0.25em;
+  }
+
+  sup {
+    top: -0.5em;
+  }
+
+  dialog {
+    padding: 0;
+  }
+
+  a {
+    color: inherit;
+    text-decoration: inherit;
+  }
+
+  abbr:where([title]) {
+    text-decoration: underline dotted;
+  }
+
+  b,
+  strong {
+    font-weight: bolder;
+  }
+
+  code,
+  kbd,
+  samp,
+  pre {
+    font-size: 1em;
+    --font-mono-fallback: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New';
+    font-family: var(--global-font-mono, var(--font-fallback));
+  }
+
+
+  input[type="text"],
+  input[type="email"],
+  input[type="search"],
+  input[type="password"] {
+    -webkit-appearance: none;
+    -moz-appearance: none; 
+  }
+
+  input[type='search'] {
+    -webkit-appearance: textfield;
+    outline-offset: -2px;
+  }
+
+  ::-webkit-search-decoration,
+  ::-webkit-search-cancel-button {
+    -webkit-appearance: none;
+  }
+
+  ::-webkit-file-upload-button {
+    -webkit-appearance: button;
+    font: inherit;
+  }
+
+  input[type="number"]::-webkit-inner-spin-button,
+  input[type="number"]::-webkit-outer-spin-button {
+    height: auto;
+  }
+
+  input[type='number']{
+    -moz-appearance: textfield;
+  }
+
+  :-moz-ui-invalid {
+    box-shadow: none;
+  }
+
+  :-moz-focusring {
+    outline: auto;
+  }
+}