@luxonis/depthai-pipeline-lib 1.4.8

package/dist/src/styled-system/css/sva.mjs

@@ -0,0 +1,35 @@
+import { getSlotRecipes, splitProps } from '../helpers.mjs';
+import { cva } from './cva.mjs';
+
+export function sva(config) {
+  const slots = Object.entries(getSlotRecipes(config)).map(([slot, slotCva]) => [slot, cva(slotCva)])
+
+  function svaFn(props) {
+    const result = slots.map(([slot, cvaFn]) => [slot, cvaFn(props)])
+    return Object.fromEntries(result)
+  }
+
+  function raw(props) {
+    const result = slots.map(([slot, cvaFn]) => [slot, cvaFn.raw(props)])
+    return Object.fromEntries(result)
+  }
+
+  const variants = config.variants ?? {};
+  const variantKeys = Object.keys(variants);
+
+  function splitVariantProps(props) {
+    return splitProps(props, variantKeys);
+  }
+
+  const variantMap = Object.fromEntries(
+    Object.entries(variants).map(([key, value]) => [key, Object.keys(value)])
+  );
+
+  return Object.assign(svaFn, {
+    __cva__: false,
+    raw,
+    variantMap,
+    variantKeys,
+    splitVariantProps,
+  })
+}

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

@@ -0,0 +1,70 @@
+@layer base {
+  :root {
+    --made-with-panda: '🐼'
+    }
+
+  *, *::before, *::after, ::backdrop {
+    --blur:   ;
+    --brightness:   ;
+    --contrast:   ;
+    --grayscale:   ;
+    --hue-rotate:   ;
+    --invert:   ;
+    --saturate:   ;
+    --sepia:   ;
+    --drop-shadow:   ;
+    --backdrop-blur:   ;
+    --backdrop-brightness:   ;
+    --backdrop-contrast:   ;
+    --backdrop-grayscale:   ;
+    --backdrop-hue-rotate:   ;
+    --backdrop-invert:   ;
+    --backdrop-opacity:   ;
+    --backdrop-saturate:   ;
+    --backdrop-sepia:   ;
+    --scroll-snap-strictness: proximity;
+    --border-spacing-x: 0;
+    --border-spacing-y: 0;
+    --translate-x: 0;
+    --translate-y: 0;
+    --rotate: 0;
+    --skew-x: 0;
+    --skew-y: 0;
+    --scale-x: 1;
+    --scale-y: 1
+    }
+
+  html {
+    -moz-osx-font-smoothing: grayscale;
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -webkit-text-size-adjust: 100%
+    }
+
+  body {
+    background: var(--colors-background);
+    color: var(--colors-foreground);
+    font-family: var(--fonts-sans)
+    }
+
+  button {
+    color: inherit;
+    outline: 2px solid transparent
+    }
+
+  * {
+    box-sizing: border-box;
+    font-family: var(--fonts-body)
+    }
+
+  html, body {
+    margin: var(--spacing-0);
+    padding: var(--spacing-0)
+    }
+
+  #root {
+    display: flex;
+    flex-direction: column;
+    height: 100vh
+    }
+}

package/dist/src/styled-system/helpers.mjs

@@ -0,0 +1,282 @@
+// src/assert.ts
+function isObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+
+// src/compact.ts
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2]) => value2 !== void 0));
+}
+
+// src/condition.ts
+var isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+  return c.slice().filter((v) => !isBaseCondition(v));
+}
+
+// src/css-important.ts
+var importantRegex = /!(important)?$/;
+function isImportant(value) {
+  return typeof value === "string" ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+  return typeof value === "string" ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+  return typeof str === "string" ? str.replaceAll(" ", "_") : str;
+}
+
+// src/hash.ts
+function toChar(code) {
+  return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+  let name = "";
+  let x;
+  for (x = Math.abs(code); x > 52; x = x / 52 | 0)
+    name = toChar(x % 52) + name;
+  return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+  let i = x.length;
+  while (i)
+    h = h * 33 ^ x.charCodeAt(--i);
+  return h;
+}
+function toHash(value) {
+  return toName(toPhash(5381, value) >>> 0);
+}
+
+// src/merge-props.ts
+function mergeProps(...sources) {
+  const result = {};
+  for (const source of sources) {
+    for (const [key, value] of Object.entries(source)) {
+      if (isObject(value)) {
+        result[key] = mergeProps(result[key] || {}, value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/walk-object.ts
+var isNotNullish = (element) => element != null;
+function walkObject(target, predicate, options = {}) {
+  const { stop, getKey } = options;
+  function inner(value, path = []) {
+    if (isObject(value) || Array.isArray(value)) {
+      const result = {};
+      for (const [prop, child] of Object.entries(value)) {
+        const key = getKey?.(prop) ?? prop;
+        const childPath = [...path, key];
+        if (stop?.(value, childPath)) {
+          return predicate(value, path);
+        }
+        const next = inner(child, childPath);
+        if (isNotNullish(next)) {
+          result[key] = next;
+        }
+      }
+      return result;
+    }
+    return predicate(value, path);
+  }
+  return inner(target);
+}
+function mapObject(obj, fn) {
+  if (!isObject(obj))
+    return fn(obj);
+  return walkObject(obj, (value) => fn(value));
+}
+
+// src/normalize-style-object.ts
+function toResponsiveObject(values, breakpoints) {
+  return values.reduce((acc, current, index) => {
+    const key = breakpoints[index];
+    if (current != null) {
+      acc[key] = current;
+    }
+    return acc;
+  }, {});
+}
+function normalizeShorthand(styles, context) {
+  const { hasShorthand, resolveShorthand } = context.utility;
+  return walkObject(styles, (v) => v, {
+    getKey: (prop) => {
+      return hasShorthand ? resolveShorthand(prop) : prop;
+    }
+  });
+}
+function normalizeStyleObject(styles, context) {
+  const { utility, conditions } = context;
+  const { hasShorthand, resolveShorthand } = utility;
+  return walkObject(
+    styles,
+    (value) => {
+      return Array.isArray(value) ? toResponsiveObject(value, conditions.breakpoints.keys) : value;
+    },
+    {
+      stop: (value) => Array.isArray(value),
+      getKey: (prop) => {
+        return hasShorthand ? resolveShorthand(prop) : prop;
+      }
+    }
+  );
+}
+
+// src/classname.ts
+var fallbackCondition = {
+  shift: (v) => v,
+  finalize: (v) => v,
+  breakpoints: { keys: [] }
+};
+var sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+function createCss(context) {
+  const { utility, hash, conditions: conds = fallbackCondition } = context;
+  const formatClassName = (str) => [utility.prefix, str].filter(Boolean).join("-");
+  const hashFn = (conditions, className) => {
+    let result;
+    if (hash) {
+      const baseArray = [...conds.finalize(conditions), className];
+      result = formatClassName(toHash(baseArray.join(":")));
+    } else {
+      const baseArray = [...conds.finalize(conditions), formatClassName(className)];
+      result = baseArray.join(":");
+    }
+    return result;
+  };
+  return (styleObject = {}) => {
+    const normalizedObject = normalizeStyleObject(styleObject, context);
+    const classNames = /* @__PURE__ */ new Set();
+    walkObject(normalizedObject, (value, paths) => {
+      const important = isImportant(value);
+      if (value == null)
+        return;
+      const [prop, ...allConditions] = conds.shift(paths);
+      const conditions = filterBaseConditions(allConditions);
+      const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+      let className = hashFn(conditions, transformed.className);
+      if (important)
+        className = `${className}!`;
+      classNames.add(className);
+    });
+    return Array.from(classNames).join(" ");
+  };
+}
+function compactStyles(...styles) {
+  return styles.filter((style) => isObject(style) && Object.keys(compact(style)).length > 0);
+}
+function createMergeCss(context) {
+  function resolve(styles) {
+    const allStyles = compactStyles(...styles);
+    if (allStyles.length === 1)
+      return allStyles;
+    return allStyles.map((style) => normalizeShorthand(style, context));
+  }
+  function mergeCss(...styles) {
+    return mergeProps(...resolve(styles));
+  }
+  function assignCss(...styles) {
+    return Object.assign({}, ...resolve(styles));
+  }
+  return { mergeCss, assignCss };
+}
+
+// src/memo.ts
+var memo = (fn) => {
+  const cache = /* @__PURE__ */ new Map();
+  const get = (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+  return get;
+};
+
+// src/hypenate-property.ts
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = memo((property) => {
+  if (property.startsWith("--"))
+    return property;
+  return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+
+// src/slot.ts
+var getSlotRecipes = (recipe = {}) => {
+  const init = (slot) => ({
+    className: [recipe.className, slot].filter(Boolean).join("__"),
+    base: recipe.base?.[slot] ?? {},
+    variants: {},
+    defaultVariants: recipe.defaultVariants ?? {},
+    compoundVariants: recipe.compoundVariants ? getSlotCompoundVariant(recipe.compoundVariants, slot) : []
+  });
+  const slots = recipe.slots ?? [];
+  const recipeParts = slots.map((slot) => [slot, init(slot)]);
+  for (const [variantsKey, variantsSpec] of Object.entries(recipe.variants ?? {})) {
+    for (const [variantKey, variantSpec] of Object.entries(variantsSpec)) {
+      recipeParts.forEach(([slot, slotRecipe]) => {
+        slotRecipe.variants[variantsKey] ??= {};
+        slotRecipe.variants[variantsKey][variantKey] = variantSpec[slot] ?? {};
+      });
+    }
+  }
+  return Object.fromEntries(recipeParts);
+};
+var getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({ ...compoundVariant, css: compoundVariant.css[slotName] }));
+
+// src/split-props.ts
+function splitProps(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const dKeys = Object.keys(descriptors);
+  const split = (k) => {
+    const clone = {};
+    for (let i = 0; i < k.length; i++) {
+      const key = k[i];
+      if (descriptors[key]) {
+        Object.defineProperty(clone, key, descriptors[key]);
+        delete descriptors[key];
+      }
+    }
+    return clone;
+  };
+  const fn = (key) => split(Array.isArray(key) ? key : dKeys.filter(key));
+  return keys.map(fn).concat(split(dKeys));
+}
+export {
+  compact,
+  createCss,
+  createMergeCss,
+  filterBaseConditions,
+  getSlotCompoundVariant,
+  getSlotRecipes,
+  hypenateProperty,
+  isBaseCondition,
+  isObject,
+  mapObject,
+  memo,
+  mergeProps,
+  splitProps,
+  toHash,
+  walkObject,
+  withoutSpace
+};
+
+
+
+
+
+export function __spreadValues(a, b) {
+  return { ...a, ...b }
+}
+
+export function __objRest(source, exclude) {
+  return Object.fromEntries(Object.entries(source).filter(([key]) => !exclude.includes(key)))
+}

package/dist/src/styled-system/patterns/aspect-ratio.d.mts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface AspectRatioProperties {
+   ratio?: ConditionalValue<number>
+}
+
+
+interface AspectRatioStyles extends AspectRatioProperties, DistributiveOmit<SystemStyleObject, keyof AspectRatioProperties | 'aspectRatio'> {}
+
+interface AspectRatioPatternFn {
+  (styles?: AspectRatioStyles): string
+  raw: (styles?: AspectRatioStyles) => SystemStyleObject
+}
+
+
+export declare const aspectRatio: AspectRatioPatternFn;

package/dist/src/styled-system/patterns/aspect-ratio.mjs

@@ -0,0 +1,35 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const aspectRatioConfig = {
+transform(props, { map }) {
+  const { ratio = 4 / 3, ...rest } = props;
+  return {
+    position: "relative",
+    _before: {
+      content: `""`,
+      display: "block",
+      height: "0",
+      paddingBottom: map(ratio, (r) => `${1 / r * 100}%`)
+    },
+    "&>*": {
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center",
+      overflow: "hidden",
+      position: "absolute",
+      inset: "0",
+      width: "100%",
+      height: "100%"
+    },
+    "&>img, &>video": {
+      objectFit: "cover"
+    },
+    ...rest
+  };
+}}
+
+export const getAspectRatioStyle = (styles = {}) => aspectRatioConfig.transform(styles, { map: mapObject })
+
+export const aspectRatio = (styles) => css(getAspectRatioStyle(styles))
+aspectRatio.raw = getAspectRatioStyle

package/dist/src/styled-system/patterns/bleed.d.mts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface BleedProperties {
+   inline?: PropertyValue<'marginInline'>
+	block?: PropertyValue<'marginBlock'>
+}
+
+
+interface BleedStyles extends BleedProperties, DistributiveOmit<SystemStyleObject, keyof BleedProperties > {}
+
+interface BleedPatternFn {
+  (styles?: BleedStyles): string
+  raw: (styles?: BleedStyles) => SystemStyleObject
+}
+
+
+export declare const bleed: BleedPatternFn;

package/dist/src/styled-system/patterns/bleed.mjs

@@ -0,0 +1,19 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const bleedConfig = {
+transform(props) {
+  const { inline = "0", block = "0", ...rest } = props;
+  return {
+    "--bleed-x": `spacing.${inline}`,
+    "--bleed-y": `spacing.${block}`,
+    marginInline: "calc(var(--bleed-x, 0) * -1)",
+    marginBlock: "calc(var(--bleed-y, 0) * -1)",
+    ...rest
+  };
+}}
+
+export const getBleedStyle = (styles = {}) => bleedConfig.transform(styles, { map: mapObject })
+
+export const bleed = (styles) => css(getBleedStyle(styles))
+bleed.raw = getBleedStyle

package/dist/src/styled-system/patterns/box.d.mts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface BoxProperties {
+   
+}
+
+
+interface BoxStyles extends BoxProperties, DistributiveOmit<SystemStyleObject, keyof BoxProperties > {}
+
+interface BoxPatternFn {
+  (styles?: BoxStyles): string
+  raw: (styles?: BoxStyles) => SystemStyleObject
+}
+
+
+export declare const box: BoxPatternFn;

package/dist/src/styled-system/patterns/box.mjs

@@ -0,0 +1,12 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const boxConfig = {
+transform(props) {
+  return props;
+}}
+
+export const getBoxStyle = (styles = {}) => boxConfig.transform(styles, { map: mapObject })
+
+export const box = (styles) => css(getBoxStyle(styles))
+box.raw = getBoxStyle

package/dist/src/styled-system/patterns/center.d.mts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface CenterProperties {
+   inline?: ConditionalValue<boolean>
+}
+
+
+interface CenterStyles extends CenterProperties, DistributiveOmit<SystemStyleObject, keyof CenterProperties > {}
+
+interface CenterPatternFn {
+  (styles?: CenterStyles): string
+  raw: (styles?: CenterStyles) => SystemStyleObject
+}
+
+
+export declare const center: CenterPatternFn;

package/dist/src/styled-system/patterns/center.mjs

@@ -0,0 +1,18 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const centerConfig = {
+transform(props) {
+  const { inline, ...rest } = props;
+  return {
+    display: inline ? "inline-flex" : "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    ...rest
+  };
+}}
+
+export const getCenterStyle = (styles = {}) => centerConfig.transform(styles, { map: mapObject })
+
+export const center = (styles) => css(getCenterStyle(styles))
+center.raw = getCenterStyle

package/dist/src/styled-system/patterns/circle.d.mts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface CircleProperties {
+   size?: PropertyValue<'width'>
+}
+
+
+interface CircleStyles extends CircleProperties, DistributiveOmit<SystemStyleObject, keyof CircleProperties > {}
+
+interface CirclePatternFn {
+  (styles?: CircleStyles): string
+  raw: (styles?: CircleStyles) => SystemStyleObject
+}
+
+
+export declare const circle: CirclePatternFn;

package/dist/src/styled-system/patterns/circle.mjs

@@ -0,0 +1,22 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const circleConfig = {
+transform(props) {
+  const { size, ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    flex: "0 0 auto",
+    width: size,
+    height: size,
+    borderRadius: "9999px",
+    ...rest
+  };
+}}
+
+export const getCircleStyle = (styles = {}) => circleConfig.transform(styles, { map: mapObject })
+
+export const circle = (styles) => css(getCircleStyle(styles))
+circle.raw = getCircleStyle

package/dist/src/styled-system/patterns/container.d.mts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface ContainerProperties {
+   
+}
+
+
+interface ContainerStyles extends ContainerProperties, DistributiveOmit<SystemStyleObject, keyof ContainerProperties > {}
+
+interface ContainerPatternFn {
+  (styles?: ContainerStyles): string
+  raw: (styles?: ContainerStyles) => SystemStyleObject
+}
+
+
+export declare const container: ContainerPatternFn;

package/dist/src/styled-system/patterns/container.mjs

@@ -0,0 +1,18 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const containerConfig = {
+transform(props) {
+  return {
+    position: "relative",
+    maxWidth: "8xl",
+    mx: "auto",
+    px: { base: "4", md: "6", lg: "8" },
+    ...props
+  };
+}}
+
+export const getContainerStyle = (styles = {}) => containerConfig.transform(styles, { map: mapObject })
+
+export const container = (styles) => css(getContainerStyle(styles))
+container.raw = getContainerStyle

package/dist/src/styled-system/patterns/divider.d.mts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface DividerProperties {
+   orientation?: ConditionalValue<"horizontal" | "vertical">
+	thickness?: ConditionalValue<Tokens["sizes"] | Properties["borderWidth"]>
+	color?: ConditionalValue<Tokens["colors"] | Properties["borderColor"]>
+}
+
+
+interface DividerStyles extends DividerProperties, DistributiveOmit<SystemStyleObject, keyof DividerProperties > {}
+
+interface DividerPatternFn {
+  (styles?: DividerStyles): string
+  raw: (styles?: DividerStyles) => SystemStyleObject
+}
+
+
+export declare const divider: DividerPatternFn;