@luxonis/common-fe-components 1.9.5

package/dist/styled-system/recipes/collapsible.d.mts

@@ -0,0 +1,27 @@
+/* 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" | "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/styled-system/recipes/collapsible.mjs

@@ -0,0 +1,50 @@
+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"
+  ],
+  [
+    "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/styled-system/recipes/command-dialog.d.mts

@@ -0,0 +1,27 @@
+/* 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" | "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/styled-system/recipes/command-dialog.mjs

@@ -0,0 +1,42 @@
+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"
+  ],
+  [
+    "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/styled-system/recipes/command.d.mts

@@ -0,0 +1,27 @@
+/* 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" | "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

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

@@ -0,0 +1,106 @@
+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"
+  ],
+  [
+    "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/styled-system/recipes/context-menu.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } 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]> | 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" | "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/styled-system/recipes/context-menu.mjs

@@ -0,0 +1,162 @@
+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"
+  ],
+  [
+    "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/styled-system/recipes/create-recipe.d.mts

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

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

@@ -0,0 +1,79 @@
+import { finalizeConditions, sortConditions } from '../css/conditions.mjs';
+import { css } from '../css/css.mjs';
+import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.mjs';
+import { cx } from '../css/cx.mjs';
+import { compact, createCss, splitProps, uniq, 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({
+     
+     conditions: {
+       shift: sortConditions,
+       finalize: finalizeConditions,
+       breakpoints: { keys: ["base","sm","md","lg","2lg","xl","2xl"] }
+     },
+     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));
+     },
+   })
+}
+
+export const mergeRecipes = (recipeA, recipeB) => {
+ if (recipeA && !recipeB) return recipeA
+ if (!recipeA && recipeB) return recipeB
+
+ const recipeFn = (...args) => cx(recipeA(...args), recipeB(...args))
+ const variantKeys = uniq(recipeA.variantKeys, recipeB.variantKeys)
+ const variantMap = variantKeys.reduce((acc, key) => {
+   acc[key] = uniq(recipeA.variantMap[key], recipeB.variantMap[key])
+   return acc
+ }, {})
+
+ return Object.assign(recipeFn, {
+   __recipe__: true,
+   __name__: `${recipeA.__name__} ${recipeB.__name__}`,
+   raw: (props) => props,
+   variantKeys,
+   variantMap,
+   splitVariantProps(props) {
+     return splitProps(props, variantKeys)
+   },
+ })
+ }

package/dist/styled-system/recipes/dialog.d.mts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { DistributiveOmit, Pretty } 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]> | undefined
+}
+
+export interface DialogRecipe {
+  __type: DialogVariantProps
+  (props?: DialogVariantProps): Pretty<Record<"root" | "trigger" | "portal" | "overlay" | "close" | "content" | "header" | "footer" | "title" | "description" | "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/styled-system/recipes/dialog.mjs

@@ -0,0 +1,106 @@
+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"
+  ],
+  [
+    "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)
+  },
+})