@luxonis/common-fe-components 1.9.5

package/dist/styled-system/helpers.mjs

@@ -0,0 +1,300 @@
+// 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 objects = sources.filter(Boolean);
+  return objects.reduce((prev, obj) => {
+    Object.keys(obj).forEach((key) => {
+      const prevValue = prev[key];
+      const value = obj[key];
+      if (isObject(prevValue) && isObject(value)) {
+        prev[key] = mergeProps(prevValue, value);
+      } else {
+        prev[key] = value;
+      }
+    });
+    return prev;
+  }, {});
+}
+
+// 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 (Array.isArray(obj))
+    return obj.map((value) => fn(value));
+  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, shorthand = true) {
+  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: shorthand ? (prop) => hasShorthand ? resolveShorthand(prop) : prop : void 0
+    }
+  );
+}
+
+// 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));
+}
+
+// src/uniq.ts
+var uniq = (...items) => items.filter(Boolean).reduce((acc, item) => Array.from(/* @__PURE__ */ new Set([...acc, ...item])), []);
+export {
+  compact,
+  createCss,
+  createMergeCss,
+  filterBaseConditions,
+  getSlotCompoundVariant,
+  getSlotRecipes,
+  hypenateProperty,
+  isBaseCondition,
+  isObject,
+  mapObject,
+  memo,
+  mergeProps,
+  splitProps,
+  toHash,
+  uniq,
+  walkObject,
+  withoutSpace
+};
+
+
+
+// src/normalize-html.ts
+var htmlProps = ["htmlSize", "htmlTranslate", "htmlWidth", "htmlHeight"];
+function convert(key) {
+  return htmlProps.includes(key) ? key.replace("html", "").toLowerCase() : key;
+}
+function normalizeHTMLProps(props) {
+  return Object.fromEntries(Object.entries(props).map(([key, value]) => [convert(key), value]));
+}
+normalizeHTMLProps.keys = htmlProps;
+export {
+  normalizeHTMLProps
+};
+
+
+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/styled-system/jsx/aspect-ratio.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { AspectRatioProperties } from '../patterns/aspect-ratio.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface AspectRatioProps extends AspectRatioProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof AspectRatioProperties | 'aspectRatio'> {}
+
+
+export declare const AspectRatio: FunctionComponent<AspectRatioProps>

package/dist/styled-system/jsx/aspect-ratio.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getAspectRatioStyle } from '../patterns/aspect-ratio.mjs';
+import { styled } from './factory.mjs';
+
+export const AspectRatio = /* @__PURE__ */ forwardRef(function AspectRatio(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["ratio"])
+
+const styleProps = getAspectRatioStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/bleed.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { BleedProperties } from '../patterns/bleed.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface BleedProps extends BleedProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof BleedProperties > {}
+
+
+export declare const Bleed: FunctionComponent<BleedProps>

package/dist/styled-system/jsx/bleed.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getBleedStyle } from '../patterns/bleed.mjs';
+import { styled } from './factory.mjs';
+
+export const Bleed = /* @__PURE__ */ forwardRef(function Bleed(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["inline","block"])
+
+const styleProps = getBleedStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/box.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { BoxProperties } from '../patterns/box.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface BoxProps extends BoxProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof BoxProperties > {}
+
+
+export declare const Box: FunctionComponent<BoxProps>

package/dist/styled-system/jsx/box.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getBoxStyle } from '../patterns/box.mjs';
+import { styled } from './factory.mjs';
+
+export const Box = /* @__PURE__ */ forwardRef(function Box(props, ref) {
+  const [patternProps, restProps] = splitProps(props, [])
+
+const styleProps = getBoxStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/center.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { CenterProperties } from '../patterns/center.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface CenterProps extends CenterProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof CenterProperties > {}
+
+
+export declare const Center: FunctionComponent<CenterProps>

package/dist/styled-system/jsx/center.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getCenterStyle } from '../patterns/center.mjs';
+import { styled } from './factory.mjs';
+
+export const Center = /* @__PURE__ */ forwardRef(function Center(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["inline"])
+
+const styleProps = getCenterStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/circle.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { CircleProperties } from '../patterns/circle.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface CircleProps extends CircleProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof CircleProperties > {}
+
+
+export declare const Circle: FunctionComponent<CircleProps>

package/dist/styled-system/jsx/circle.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getCircleStyle } from '../patterns/circle.mjs';
+import { styled } from './factory.mjs';
+
+export const Circle = /* @__PURE__ */ forwardRef(function Circle(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["size"])
+
+const styleProps = getCircleStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/container.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { ContainerProperties } from '../patterns/container.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface ContainerProps extends ContainerProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof ContainerProperties > {}
+
+
+export declare const Container: FunctionComponent<ContainerProps>

package/dist/styled-system/jsx/container.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getContainerStyle } from '../patterns/container.mjs';
+import { styled } from './factory.mjs';
+
+export const Container = /* @__PURE__ */ forwardRef(function Container(props, ref) {
+  const [patternProps, restProps] = splitProps(props, [])
+
+const styleProps = getContainerStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/divider.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { DividerProperties } from '../patterns/divider.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface DividerProps extends DividerProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof DividerProperties > {}
+
+
+export declare const Divider: FunctionComponent<DividerProps>

package/dist/styled-system/jsx/divider.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getDividerStyle } from '../patterns/divider.mjs';
+import { styled } from './factory.mjs';
+
+export const Divider = /* @__PURE__ */ forwardRef(function Divider(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["orientation","thickness","color"])
+
+const styleProps = getDividerStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/factory-helper.mjs

@@ -0,0 +1,22 @@
+import { isCssProperty } from './is-valid-prop.mjs';
+
+export const defaultShouldForwardProp = (prop, variantKeys) => !variantKeys.includes(prop) && !isCssProperty(prop)
+
+export const composeShouldForwardProps = (tag, shouldForwardProp) =>
+  tag.__shouldForwardProps__ && shouldForwardProp
+    ? (propName) => tag.__shouldForwardProps__(propName) && shouldForwardProp(propName)
+    : shouldForwardProp
+
+export const composeCvaFn = (cvaA, cvaB) => {
+  if (cvaA && !cvaB) return cvaA
+  if (!cvaA && cvaB) return cvaB
+  if ((cvaA.__cva__ && cvaB.__cva__) || (cvaA.__recipe__ && cvaB.__recipe__)) return cvaA.merge(cvaB)
+  const error = new TypeError('Cannot merge cva with recipe. Please use either cva or recipe.')
+  TypeError.captureStackTrace?.(error)
+  throw error
+}
+
+export const getDisplayName = (Component) => {
+  if (typeof Component === 'string') return Component
+  return Component?.displayName || Component?.name || 'Component'
+}

package/dist/styled-system/jsx/factory.d.mts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+import type { Styled } from '../types/jsx.d.mts';
+export declare const styled: Styled

package/dist/styled-system/jsx/factory.mjs

@@ -0,0 +1,79 @@
+import { createElement, forwardRef, useMemo } from 'react'
+import { css, cx, cva } from '../css/index.mjs';
+import { defaultShouldForwardProp, composeShouldForwardProps, composeCvaFn, getDisplayName } from './factory-helper.mjs';
+import { splitProps, normalizeHTMLProps } from '../helpers.mjs';
+import { isCssProperty } from './is-valid-prop.mjs';
+
+function styledFn(Dynamic, configOrCva = {}, options = {}) {
+  const cvaFn = configOrCva.__cva__ || configOrCva.__recipe__ ? configOrCva : cva(configOrCva)
+
+  const forwardFn = options.shouldForwardProp || defaultShouldForwardProp
+  const shouldForwardProp = (prop) => forwardFn(prop, cvaFn.variantKeys)
+
+  const defaultProps = Object.assign(
+    options.dataAttr && configOrCva.__name__ ? { 'data-recipe': configOrCva.__name__ } : {},
+    options.defaultProps,
+  )
+
+  const StyledComponent = /* @__PURE__ */ forwardRef(function StyledComponent(props, ref) {
+    const { as: Element = Dynamic.__base__ || Dynamic, children, ...restProps } = props
+
+    const __cvaFn__ = composeCvaFn(Dynamic.__cva__, cvaFn)
+    const __shouldForwardProps__ = composeShouldForwardProps(Dynamic, shouldForwardProp)
+
+    const combinedProps = useMemo(() => Object.assign({}, defaultProps, restProps), [restProps])
+
+    const [htmlProps, forwardedProps, variantProps, styleProps, elementProps] = useMemo(() => {
+      return splitProps(combinedProps, normalizeHTMLProps.keys, __shouldForwardProps__, __cvaFn__.variantKeys, isCssProperty)
+    }, [combinedProps])
+
+    function recipeClass() {
+      const { css: cssStyles, ...propStyles } = styleProps
+      const compoundVariantStyles = __cvaFn__.__getCompoundVariantCss__?.(variantProps)
+      return cx(__cvaFn__(variantProps, false), css(compoundVariantStyles, propStyles, cssStyles), combinedProps.className)
+    }
+
+    function cvaClass() {
+      const { css: cssStyles, ...propStyles } = styleProps
+      const cvaStyles = __cvaFn__.raw(variantProps)
+      return cx(css(cvaStyles, propStyles, cssStyles), combinedProps.className)
+    }
+
+    const classes = configOrCva.__recipe__ ? recipeClass : cvaClass
+
+    return createElement(Element, {
+      ref,
+      ...forwardedProps,
+      ...elementProps,
+      ...normalizeHTMLProps(htmlProps),
+      className: classes(),
+    }, combinedProps.children ?? children)
+  })
+
+  const name = getDisplayName(Dynamic)
+
+  StyledComponent.displayName = `styled.${name}`
+  StyledComponent.__cva__ = cvaFn
+  StyledComponent.__base__ = Dynamic
+  StyledComponent.__shouldForwardProps__ = shouldForwardProp
+
+  return StyledComponent
+}
+
+function createJsxFactory() {
+  const cache = new Map()
+
+  return new Proxy(styledFn, {
+    apply(_, __, args) {
+      return styledFn(...args)
+    },
+    get(_, el) {
+      if (!cache.has(el)) {
+        cache.set(el, styledFn(el))
+      }
+      return cache.get(el)
+    },
+  })
+}
+
+export const styled = /* @__PURE__ */ createJsxFactory()

package/dist/styled-system/jsx/flex.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { FlexProperties } from '../patterns/flex.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface FlexProps extends FlexProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof FlexProperties > {}
+
+
+export declare const Flex: FunctionComponent<FlexProps>

package/dist/styled-system/jsx/flex.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getFlexStyle } from '../patterns/flex.mjs';
+import { styled } from './factory.mjs';
+
+export const Flex = /* @__PURE__ */ forwardRef(function Flex(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["align","justify","direction","wrap","basis","grow","shrink"])
+
+const styleProps = getFlexStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/float.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { FloatProperties } from '../patterns/float.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface FloatProps extends FloatProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof FloatProperties > {}
+
+
+export declare const Float: FunctionComponent<FloatProps>

package/dist/styled-system/jsx/float.mjs

@@ -0,0 +1,14 @@
+import { createElement, forwardRef } from 'react'
+import { mergeCss } from '../css/css.mjs';
+import { splitProps } from '../helpers.mjs';
+import { getFloatStyle } from '../patterns/float.mjs';
+import { styled } from './factory.mjs';
+
+export const Float = /* @__PURE__ */ forwardRef(function Float(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["offsetX","offsetY","offset","placement"])
+
+const styleProps = getFloatStyle(patternProps)
+const mergedProps = { ref, ...styleProps, ...restProps }
+
+return createElement(styled.div, mergedProps)
+  })

package/dist/styled-system/jsx/grid-item.d.mts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { GridItemProperties } from '../patterns/grid-item.d.mts';
+import type { HTMLStyledProps } from '../types/jsx.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+export interface GridItemProps extends GridItemProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof GridItemProperties > {}
+
+
+export declare const GridItem: FunctionComponent<GridItemProps>