@festo-ui/react 9.0.0-dev.718 → 9.0.0-dev.720

package/dist/utils/types.d.ts

@@ -0,0 +1,29 @@
+export interface ClassNameProps {
+    className?: string;
+}
+export interface ClassNamePropsWithChildren extends ClassNameProps {
+    children?: React.ReactNode;
+}
+export interface Image {
+    src: string;
+    alt: string;
+    aspectRatio: '3/2' | '16/9';
+}
+export interface SelectConfiguration {
+    hideLabel?: boolean;
+    contentWidth?: string;
+    scroll?: {
+        enabled?: boolean;
+        viewportSize?: number;
+    };
+}
+export type PolymorphicRef<C extends React.ElementType> = React.ComponentPropsWithRef<C>['ref'];
+type AsProp<C extends React.ElementType> = {
+    component?: C;
+};
+type PropsToOmit<C extends React.ElementType, P> = keyof (AsProp<C> & P);
+type PolymorphicComponentProp<C extends React.ElementType, Props = object> = React.PropsWithChildren<Props & AsProp<C>> & Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit<C, Props>>;
+export type PolymorphicComponentPropWithRef<C extends React.ElementType, Props = object> = PolymorphicComponentProp<C, Props> & {
+    ref?: PolymorphicRef<C>;
+};
+export {};

package/dist/utils/useControlled.d.ts

@@ -0,0 +1,7 @@
+import { type Dispatch, type SetStateAction } from 'react';
+export interface UseControlledProps<T> {
+    controlled: T | undefined;
+    default: T;
+    onChange?: (value: T) => void;
+}
+export declare function useControlled<T>({ controlled, default: defaultValue, onChange, }: UseControlledProps<T>): [T | undefined, Dispatch<SetStateAction<T>>];

package/dist/utils/useControlled.js

@@ -0,0 +1,20 @@
+import { useCallback, useRef, useState } from "react";
+function useControlled({ controlled, default: defaultValue, onChange }) {
+    const { current: isControlled } = useRef(void 0 !== controlled);
+    const [valueState, setValue] = useState(defaultValue);
+    const value = isControlled ? controlled : valueState;
+    const setValueIfUncontrolled = useCallback((newValue)=>{
+        if (!isControlled) setValue(newValue);
+        const setter = newValue;
+        const onChangeValue = 'function' == typeof newValue ? setter(controlled) : newValue;
+        onChange?.(onChangeValue);
+    }, [
+        controlled,
+        onChange
+    ]);
+    return [
+        value,
+        setValueIfUncontrolled
+    ];
+}
+export { useControlled };

package/dist/utils/useForkRef.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function useForkRef<T>(refA: React.Ref<T> | null | undefined, refB: React.Ref<T> | null | undefined): React.RefCallback<T> | null;

package/dist/utils/useForkRef.js

@@ -0,0 +1,15 @@
+import react from "react";
+import { setRef } from "./setRef.js";
+function useForkRef(refA, refB) {
+    return react.useMemo(()=>{
+        if (null == refA && (null == refB || void 0 === refB)) return null;
+        return (instance)=>{
+            setRef(refA, instance);
+            setRef(refB, instance);
+        };
+    }, [
+        refA,
+        refB
+    ]);
+}
+export { useForkRef };

package/dist/utils/useId.d.ts

@@ -0,0 +1 @@
+export declare function useId(idInput?: string): string | undefined;

package/dist/utils/useId.js

@@ -0,0 +1,20 @@
+import react from "react";
+const maybeReactUseId = react["useId"];
+let nextId = 0;
+function useLegacyId() {
+    const [id, setId] = react.useState(void 0);
+    react.useEffect(()=>{
+        if (null == id) {
+            nextId += 1;
+            setId(`fr-${nextId}`);
+        }
+    }, [
+        id
+    ]);
+    return id;
+}
+function useId(idInput) {
+    if (null != idInput) return idInput;
+    return maybeReactUseId ? maybeReactUseId() : useLegacyId();
+}
+export { useId };

package/dist/utils/useOnClickOutside.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare function useOnClickOutside(ref: RefObject<HTMLElement>, callback: (event: MouseEvent | TouchEvent) => void, ref2?: RefObject<HTMLElement>): void;

package/dist/utils/useOnClickOutside.js

@@ -0,0 +1,20 @@
+import { useEffect } from "react";
+function useOnClickOutside(ref, callback, ref2) {
+    useEffect(()=>{
+        const listener = (event)=>{
+            if (!ref.current || ref.current.contains(event.target) || ref2 && (!ref2.current || ref2.current.contains(event.target))) return;
+            callback(event);
+        };
+        document.addEventListener('mousedown', listener, true);
+        document.addEventListener('touchstart', listener, true);
+        return ()=>{
+            document.removeEventListener('mousedown', listener, true);
+            document.removeEventListener('touchstart', listener, true);
+        };
+    }, [
+        ref,
+        ref2,
+        callback
+    ]);
+}
+export { useOnClickOutside };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@festo-ui/react",
-  "version": "9.0.0-dev.718",
+  "version": "9.0.0-dev.720",
   "author": "Festo UI (styleguide@festo.com)",
   "copyright": "Copyright (c) 2025 Festo SE & Co. KG. All rights reserved.",
   "license": "apache-2.0",
@@ -38,7 +38,6 @@
     "react-popper": "^2.3.0",
     "react-remove-scroll": "^2.5.7",
     "react-transition-group": "^4.4.2",
-    "simplebar-react": "^3.2.6",
     "swiper": "^12.0.3"
   },
   "devDependencies": {