@intentface/chat 0.1.0

package/dist/internal/collapsible.js

@@ -0,0 +1,90 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Minimal internal disclosure primitive — replaces the @base-ui/react
+// Collapsible dependency for the package's own parts. Trigger toggles, Panel
+// hides (or unmounts) its content; state is exposed Base UI-style via
+// presence attributes (data-open / data-closed) generated from state, plus
+// the animation contract: data-starting-style on the panel's first open
+// frame, data-ending-style while its exit animations run (hide/unmount waits
+// for them), and the panel's natural height as --collapsible-panel-height.
+// Every part supports the Base UI render prop.
+import { createContext, use, useCallback, useId, useRef, useState, } from "react";
+import { useOpenTransition } from "./render/transition.js";
+import { useRenderElement } from "./render/useRenderElement.js";
+import { openStateMapping, transitionStatusMapping } from "./state-mappings.js";
+const CollapsibleContext = createContext(null);
+const useCollapsible = () => {
+    const ctx = use(CollapsibleContext);
+    if (!ctx)
+        throw new Error("Collapsible parts must be used within <Collapsible>");
+    return ctx;
+};
+const CollapsibleRoot = ({ open: controlledOpen, defaultOpen = false, onOpenChange, className, render, style, ...elementProps }) => {
+    const [internalOpen, setInternalOpen] = useState(defaultOpen);
+    const isControlled = controlledOpen !== undefined;
+    const open = isControlled ? controlledOpen : internalOpen;
+    const panelId = useId();
+    const setOpen = useCallback((value) => {
+        if (!isControlled)
+            setInternalOpen(value);
+        onOpenChange?.(value);
+    }, [isControlled, onOpenChange]);
+    const element = useRenderElement("div", { className, render, style }, {
+        state: { open },
+        stateAttributesMapping: openStateMapping,
+        props: elementProps,
+    });
+    return _jsx(CollapsibleContext, { value: { open, setOpen, panelId }, children: element });
+};
+const CollapsibleTrigger = ({ className, render, style, ...elementProps }) => {
+    const { open, setOpen, panelId } = useCollapsible();
+    return useRenderElement("button", { className, render, style }, {
+        state: { open },
+        stateAttributesMapping: openStateMapping,
+        props: [
+            {
+                "aria-expanded": open,
+                "aria-controls": panelId,
+                // mergeProps runs the consumer's onClick first (rightmost wins), so
+                // preventDefault there still cancels the toggle — same contract as
+                // the previous inline `if (!event.defaultPrevented)` handler.
+                onClick: (event) => {
+                    if (!event.defaultPrevented)
+                        setOpen(!open);
+                },
+            },
+            elementProps,
+        ],
+    });
+};
+const CollapsiblePanel = ({ keepMounted = false, className, render, style, ...elementProps }) => {
+    const { open, panelId } = useCollapsible();
+    const panelRef = useRef(null);
+    // The shared transition hook owns the open/starting/ending/close lifecycle: it keeps the
+    // panel mounted through its exit (waiting on getAnimations), measures the natural height
+    // for the CSS var, and reports the status that drives data-starting/ending-style.
+    const { mounted, transitionStatus, height } = useOpenTransition(open, panelRef, {
+        measureHeight: true,
+    });
+    const hidden = !open && !mounted;
+    return useRenderElement("div", { className, render, style }, {
+        enabled: mounted || keepMounted,
+        state: { open, transitionStatus },
+        stateAttributesMapping: { ...openStateMapping, ...transitionStatusMapping },
+        ref: panelRef,
+        props: [
+            {
+                id: panelId,
+                hidden,
+                style: height !== null
+                    ? { "--collapsible-panel-height": `${height}px` }
+                    : undefined,
+            },
+            elementProps,
+        ],
+    });
+};
+export const Collapsible = Object.assign(CollapsibleRoot, {
+    Trigger: CollapsibleTrigger,
+    Panel: CollapsiblePanel,
+});

package/dist/internal/primitive-props.d.ts

@@ -0,0 +1,4 @@
+import type * as React from "react";
+import type { BaseUIComponentProps } from "./render/types.js";
+export type EmptyState = Record<string, never>;
+export type PrimitiveProps<ElementType extends React.ElementType, State = EmptyState> = BaseUIComponentProps<ElementType, State>;

package/dist/internal/primitive-props.js

@@ -0,0 +1,4 @@
+// Neutral alias over the vendored render machinery's component-props type —
+// our primitives speak "PrimitiveProps", not the upstream brand. Adds an
+// empty-state default so stateless primitives write PrimitiveProps<"div">.
+export {};

package/dist/internal/render/baseTypes.d.ts

@@ -0,0 +1,18 @@
+import type * as React from 'react';
+export type HTMLProps<T = any> = React.HTMLAttributes<T> & {
+    ref?: React.Ref<T> | undefined;
+};
+export type WithDataAttributes<Props> = Props | (Props & {
+    [dataAttribute: `data-${string}`]: string | undefined;
+});
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+export type ComponentRenderFn<Props, State> = (props: Props, state: State) => React.ReactElement<unknown>;
+export type BaseUIEvent<E extends React.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};

package/dist/internal/render/baseTypes.js

@@ -0,0 +1,4 @@
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/types/index.ts
+// https://github.com/mui/base-ui — subset: the createBaseUIEventDetails re-export
+// is dropped (unused by the render machinery); otherwise an exact copy.
+export {};

package/dist/internal/render/empty.d.ts

@@ -0,0 +1,3 @@
+export declare function NOOP(): void;
+export declare const EMPTY_ARRAY: readonly any[];
+export declare const EMPTY_OBJECT: Readonly<{}>;

package/dist/internal/render/empty.js

@@ -0,0 +1,5 @@
+// Vendored from @base-ui/utils v1.6.0 (MIT) — packages/utils/src/empty.ts
+// https://github.com/mui/base-ui — exact copy.
+export function NOOP() { }
+export const EMPTY_ARRAY = Object.freeze([]);
+export const EMPTY_OBJECT = Object.freeze({});

package/dist/internal/render/getReactElementRef.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * Extracts the `ref` from a React element, handling different React versions.
+ */
+export declare function getReactElementRef(element: unknown): React.Ref<unknown> | null;

package/dist/internal/render/getReactElementRef.js

@@ -0,0 +1,15 @@
+// Vendored from @base-ui/utils v1.6.0 (MIT) — packages/utils/src/getReactElementRef.ts
+// https://github.com/mui/base-ui — exact copy.
+import * as React from 'react';
+import { isReactVersionAtLeast } from './reactVersion';
+/**
+ * Extracts the `ref` from a React element, handling different React versions.
+ */
+export function getReactElementRef(element) {
+    if (!React.isValidElement(element)) {
+        return null;
+    }
+    const reactElement = element;
+    const propsWithRef = reactElement.props;
+    return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}

package/dist/internal/render/getStateAttributesProps.d.ts

@@ -0,0 +1,4 @@
+export type StateAttributesMapping<State> = {
+    [Property in keyof State]?: (state: State[Property]) => Record<string, string> | null;
+};
+export declare function getStateAttributesProps<State extends Record<string, any>>(state: State, customMapping?: StateAttributesMapping<State>): Record<string, string>;

package/dist/internal/render/getStateAttributesProps.js

@@ -0,0 +1,23 @@
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/internals/getStateAttributesProps.ts
+// https://github.com/mui/base-ui — exact copy.
+export function getStateAttributesProps(state, customMapping) {
+    const props = {};
+    /* eslint-disable-next-line guard-for-in */
+    for (const key in state) {
+        const value = state[key];
+        if (customMapping?.hasOwnProperty(key)) {
+            const customProps = customMapping[key](value);
+            if (customProps != null) {
+                Object.assign(props, customProps);
+            }
+            continue;
+        }
+        if (value === true) {
+            props[`data-${key.toLowerCase()}`] = '';
+        }
+        else if (value) {
+            props[`data-${key.toLowerCase()}`] = value.toString();
+        }
+    }
+    return props;
+}

package/dist/internal/render/mergeObjects.d.ts

@@ -0,0 +1 @@
+export declare function mergeObjects<A extends object | undefined, B extends object | undefined>(a: A, b: B): NonNullable<A> | NonNullable<B> | (A & B) | undefined;

package/dist/internal/render/mergeObjects.js

@@ -0,0 +1,14 @@
+// Vendored from @base-ui/utils v1.6.0 (MIT) — packages/utils/src/mergeObjects.ts
+// https://github.com/mui/base-ui — exact copy.
+export function mergeObjects(a, b) {
+    if (a && !b) {
+        return a;
+    }
+    if (!a && b) {
+        return b;
+    }
+    if (a || b) {
+        return { ...a, ...b };
+    }
+    return undefined;
+}

package/dist/internal/render/mergeProps.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import type { BaseUIEvent, WithBaseUIEvent } from './types';
+type ElementType = React.ElementType;
+type PropsOf<T extends React.ElementType> = WithBaseUIEvent<React.ComponentPropsWithRef<T>>;
+type InputProps<T extends React.ElementType> = PropsOf<T> | ((otherProps: PropsOf<T>) => PropsOf<T>) | undefined;
+/**
+ * Merges multiple sets of React props. It follows the Object.assign pattern where the rightmost object's fields overwrite
+ * the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
+ *
+ * Event handlers are merged and called in right-to-left order (rightmost handler executes first, leftmost last).
+ * For React synthetic events, the rightmost handler can prevent prior (left-positioned) handlers from executing
+ * by calling `event.preventBaseUIHandler()`. For non-synthetic events (custom events with primitive/object values),
+ * all handlers always execute without prevention capability.
+ *
+ * The `className` prop is merged by concatenating classes in right-to-left order (rightmost class appears first in the string).
+ * The `style` prop is merged with rightmost styles overwriting the prior ones.
+ *
+ * Props can either be provided as objects or as functions that take the previous props as an argument.
+ * The function will receive the merged props up to that point (going from left to right):
+ * so in the case of `(obj1, obj2, fn, obj3)`, `fn` will receive the merged props of `obj1` and `obj2`.
+ * The function is responsible for chaining event handlers if needed (that is, we don't run the merge logic).
+ *
+ * Event handlers returned by the functions are not automatically prevented when `preventBaseUIHandler` is called.
+ * They must check `event.baseUIHandlerPrevented` themselves and bail out if it's true.
+ *
+ * @important **`ref` is not merged.**
+ * @param a Props object to merge.
+ * @param b Props object to merge. The function will overwrite conflicting props from `a`.
+ * @param c Props object to merge. The function will overwrite conflicting props from previous parameters.
+ * @param d Props object to merge. The function will overwrite conflicting props from previous parameters.
+ * @param e Props object to merge. The function will overwrite conflicting props from previous parameters.
+ * @returns The merged props.
+ * @public
+ */
+export declare function mergeProps<T extends ElementType>(a: InputProps<T>, b: InputProps<T>, c: InputProps<T>, d: InputProps<T>, e: InputProps<T>): PropsOf<T>;
+export declare function mergeProps<T extends ElementType>(a: InputProps<T>, b: InputProps<T>, c: InputProps<T>, d: InputProps<T>): PropsOf<T>;
+export declare function mergeProps<T extends ElementType>(a: InputProps<T>, b: InputProps<T>, c: InputProps<T>): PropsOf<T>;
+export declare function mergeProps<T extends ElementType>(a: InputProps<T>, b: InputProps<T>): PropsOf<T>;
+/**
+ * Merges an arbitrary number of React props using the same logic as {@link mergeProps}.
+ * This function accepts an array of props instead of individual arguments.
+ *
+ * This has slightly lower performance than {@link mergeProps} due to accepting an array
+ * instead of a fixed number of arguments. Prefer {@link mergeProps} when merging 5 or
+ * fewer prop sets for better performance.
+ *
+ * @param props Array of props to merge.
+ * @returns The merged props.
+ * @see mergeProps
+ * @public
+ */
+export declare function mergePropsN<T extends ElementType>(props: InputProps<T>[]): PropsOf<T>;
+export declare function makeEventPreventable<T extends React.SyntheticEvent>(event: BaseUIEvent<T>): BaseUIEvent<T>;
+export declare function mergeClassNames(ourClassName: string | undefined, theirClassName: string | undefined): string | undefined;
+export {};

package/dist/internal/render/mergeProps.js

@@ -0,0 +1,183 @@
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/merge-props/mergeProps.ts
+// https://github.com/mui/base-ui — exact copy; only import specifiers rewired.
+import * as React from 'react';
+import { mergeObjects } from './mergeObjects';
+const EMPTY_PROPS = {};
+export function mergeProps(a, b, c, d, e) {
+    if (!c && !d && !e && !a) {
+        return createInitialMergedProps(b);
+    }
+    // We need to mutably own `merged`.
+    let merged = createInitialMergedProps(a);
+    if (b) {
+        merged = mergeInto(merged, b);
+    }
+    if (c) {
+        merged = mergeInto(merged, c);
+    }
+    if (d) {
+        merged = mergeInto(merged, d);
+    }
+    if (e) {
+        merged = mergeInto(merged, e);
+    }
+    return merged;
+}
+/* eslint-enable id-denylist */
+/**
+ * Merges an arbitrary number of React props using the same logic as {@link mergeProps}.
+ * This function accepts an array of props instead of individual arguments.
+ *
+ * This has slightly lower performance than {@link mergeProps} due to accepting an array
+ * instead of a fixed number of arguments. Prefer {@link mergeProps} when merging 5 or
+ * fewer prop sets for better performance.
+ *
+ * @param props Array of props to merge.
+ * @returns The merged props.
+ * @see mergeProps
+ * @public
+ */
+export function mergePropsN(props) {
+    if (props.length === 0) {
+        return EMPTY_PROPS;
+    }
+    if (props.length === 1) {
+        return createInitialMergedProps(props[0]);
+    }
+    // We need to mutably own `merged`.
+    let merged = createInitialMergedProps(props[0]);
+    for (let i = 1; i < props.length; i += 1) {
+        merged = mergeInto(merged, props[i]);
+    }
+    return merged;
+}
+function createInitialMergedProps(inputProps) {
+    if (isPropsGetter(inputProps)) {
+        // Getter-returned handlers intentionally keep their existing semantics.
+        return { ...resolvePropsGetter(inputProps, EMPTY_PROPS) };
+    }
+    return copyInitialProps(inputProps);
+}
+function mergeInto(merged, inputProps) {
+    if (isPropsGetter(inputProps)) {
+        return resolvePropsGetter(inputProps, merged);
+    }
+    return mutablyMergeInto(merged, inputProps);
+}
+function copyInitialProps(inputProps) {
+    const copiedProps = { ...inputProps };
+    // `copiedProps` is our fresh own-object copy, so iterating with `for...in` is safe here.
+    // eslint-disable-next-line guard-for-in
+    for (const propName in copiedProps) {
+        const propValue = copiedProps[propName];
+        if (isEventHandler(propName, propValue)) {
+            copiedProps[propName] = wrapEventHandler(propValue);
+        }
+    }
+    return copiedProps;
+}
+/**
+ * Merges two sets of props. In case of conflicts, the external props take precedence.
+ */
+function mutablyMergeInto(mergedProps, externalProps) {
+    if (!externalProps) {
+        return mergedProps;
+    }
+    // eslint-disable-next-line guard-for-in
+    for (const propName in externalProps) {
+        const externalPropValue = externalProps[propName];
+        switch (propName) {
+            case 'style': {
+                mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
+                break;
+            }
+            case 'className': {
+                mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+                break;
+            }
+            default: {
+                if (isEventHandler(propName, externalPropValue)) {
+                    mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
+                }
+                else {
+                    mergedProps[propName] = externalPropValue;
+                }
+            }
+        }
+    }
+    return mergedProps;
+}
+function isEventHandler(key, value) {
+    // This approach is more efficient than using a regex.
+    const code0 = key.charCodeAt(0);
+    const code1 = key.charCodeAt(1);
+    const code2 = key.charCodeAt(2);
+    return (code0 === 111 /* o */ &&
+        code1 === 110 /* n */ &&
+        code2 >= 65 /* A */ &&
+        code2 <= 90 /* Z */ &&
+        (typeof value === 'function' || typeof value === 'undefined'));
+}
+function isPropsGetter(inputProps) {
+    return typeof inputProps === 'function';
+}
+function resolvePropsGetter(inputProps, previousProps) {
+    if (isPropsGetter(inputProps)) {
+        return inputProps(previousProps);
+    }
+    return inputProps ?? EMPTY_PROPS;
+}
+function mergeEventHandlers(ourHandler, theirHandler) {
+    if (!theirHandler) {
+        return ourHandler;
+    }
+    if (!ourHandler) {
+        return wrapEventHandler(theirHandler);
+    }
+    return (...args) => {
+        const event = args[0];
+        if (isSyntheticEvent(event)) {
+            const baseUIEvent = event;
+            makeEventPreventable(baseUIEvent);
+            const result = theirHandler(...args);
+            if (!baseUIEvent.baseUIHandlerPrevented) {
+                ourHandler?.(...args);
+            }
+            return result;
+        }
+        const result = theirHandler(...args);
+        ourHandler?.(...args);
+        return result;
+    };
+}
+function wrapEventHandler(handler) {
+    if (!handler) {
+        return handler;
+    }
+    return (...args) => {
+        const event = args[0];
+        if (isSyntheticEvent(event)) {
+            makeEventPreventable(event);
+        }
+        return handler(...args);
+    };
+}
+export function makeEventPreventable(event) {
+    event.preventBaseUIHandler = () => {
+        event.baseUIHandlerPrevented = true;
+    };
+    return event;
+}
+export function mergeClassNames(ourClassName, theirClassName) {
+    if (theirClassName) {
+        if (ourClassName) {
+            // eslint-disable-next-line prefer-template
+            return theirClassName + ' ' + ourClassName;
+        }
+        return theirClassName;
+    }
+    return ourClassName;
+}
+function isSyntheticEvent(event) {
+    return event != null && typeof event === 'object' && 'nativeEvent' in event;
+}

package/dist/internal/render/positioning.d.ts

@@ -0,0 +1,22 @@
+import { type RefObject } from "react";
+export type AnchorSide = "top" | "bottom" | "left" | "right";
+export type AnchorAlign = "start" | "center" | "end";
+export type UseAnchorPositioningOptions = {
+    /** Position only while true (e.g. while the surface is mounted/open). */
+    enabled?: boolean;
+    /** Preferred side; flips to the opposite when there's no room. Default "top". */
+    side?: AnchorSide;
+    /** Alignment along the side. Default "center". */
+    align?: AnchorAlign;
+    /** Gap between anchor and floating element. Default 0. */
+    sideOffset?: number;
+    /** Keep this many px from the collision boundary. Default 8. */
+    collisionPadding?: number;
+    /**
+     * Pin to `side`/`align` without collision repositioning — drops flip + shift, so the surface
+     * stays put and may run off-screen when there's no room. `size` still publishes its vars.
+     * Default false.
+     */
+    pin?: boolean;
+};
+export declare const useAnchorPositioning: (getAnchor: () => Element | null, floatingRef: RefObject<HTMLElement | null>, { enabled, side, align, sideOffset, collisionPadding, pin, }?: UseAnchorPositioningOptions) => void;

package/dist/internal/render/positioning.js

@@ -0,0 +1,78 @@
+"use client";
+// Collision-aware anchor positioning via @floating-ui/dom, shared by Composer.Popover
+// (anchored to the active command badge) and a positioned Composer.Panel (anchored to the
+// composer container). Positions the floating element with flip/shift/size and keeps it there
+// across scroll/resize/anchor movement (autoUpdate); `pin` opts out of flip/shift.
+//
+// Everything is written imperatively — no per-render React state — so a flip or a scroll never
+// re-renders the tree: `position: absolute` + left/top (page coordinates, so the surface scrolls
+// natively with the page instead of chasing the anchor a frame behind it); `--anchor-width` /
+// `--anchor-height` (the anchor's own size, e.g. so a panel can be `width: var(--anchor-width)`)
+// and `--anchor-available-height` (free space in the placement direction — cap max-height + scroll
+// instead of overflow) from the size middleware; and `data-side`/`data-align` for the transition
+// origin. Base UI-style: the styling layer opts into the vars, the primitive imposes nothing.
+import { autoUpdate, computePosition, flip, offset, shift, size, } from "@floating-ui/dom";
+import { useEffect } from "react";
+const EMPTY_RECT = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    toJSON: () => "",
+};
+export const useAnchorPositioning = (getAnchor, floatingRef, { enabled = true, side = "top", align = "center", sideOffset = 0, collisionPadding = 8, pin = false, } = {}) => {
+    useEffect(() => {
+        const floating = floatingRef.current;
+        if (!enabled || !floating)
+            return;
+        const placement = (align === "center" ? side : `${side}-${align}`);
+        // Virtual reference: re-reads the anchor rect each run, so a re-created anchor (e.g. the
+        // command badge decoration re-rendering as you type) is tracked without re-subscribing.
+        const reference = {
+            getBoundingClientRect: () => getAnchor()?.getBoundingClientRect() ?? EMPTY_RECT,
+            get contextElement() {
+                return getAnchor() ?? undefined;
+            },
+        };
+        const update = () => {
+            computePosition(reference, floating, {
+                // Absolute (page-coordinate), not fixed: portaled to the body, the surface then
+                // scrolls *with* the page natively — so following the anchor on scroll needs no
+                // per-frame JS write and can't lag a frame behind it (the "wobble"). autoUpdate
+                // still re-runs for real layout changes (flip/shift/resize/anchor movement).
+                strategy: "absolute",
+                placement,
+                middleware: [
+                    offset(sideOffset),
+                    // Collision repositioning — skipped when pinned, so the surface holds `side`/`align`.
+                    ...(pin
+                        ? []
+                        : [flip({ padding: collisionPadding }), shift({ padding: collisionPadding })]),
+                    size({
+                        padding: collisionPadding,
+                        apply({ availableHeight, rects }) {
+                            // Anchor's own size + the free space toward the placement side, published as
+                            // vars for the styling layer to consume (e.g. `width: var(--anchor-width)`,
+                            // `max-height: var(--anchor-available-height)`). Never sets width/height itself.
+                            floating.style.setProperty("--anchor-width", `${Math.round(rects.reference.width)}px`);
+                            floating.style.setProperty("--anchor-height", `${Math.round(rects.reference.height)}px`);
+                            floating.style.setProperty("--anchor-available-height", `${Math.max(0, Math.round(availableHeight))}px`);
+                        },
+                    }),
+                ],
+            }).then(({ x, y, placement: resolved }) => {
+                floating.style.position = "absolute";
+                floating.style.left = `${Math.round(x)}px`;
+                floating.style.top = `${Math.round(y)}px`;
+                const [resolvedSide = side, resolvedAlign = "center"] = resolved.split("-");
+                floating.setAttribute("data-side", resolvedSide);
+                floating.setAttribute("data-align", resolvedAlign);
+            });
+        };
+        return autoUpdate(reference, floating, update);
+    }, [enabled, getAnchor, floatingRef, side, align, sideOffset, collisionPadding, pin]);
+};

package/dist/internal/render/reactVersion.d.ts

@@ -0,0 +1,3 @@
+type SupportedVersions = 17 | 18 | 19;
+export declare function isReactVersionAtLeast(reactVersionToCheck: SupportedVersions): boolean;
+export {};

package/dist/internal/render/reactVersion.js

@@ -0,0 +1,7 @@
+// Vendored from @base-ui/utils v1.6.0 (MIT) — packages/utils/src/reactVersion.ts
+// https://github.com/mui/base-ui — exact copy.
+import * as React from 'react';
+const majorVersion = parseInt(React.version, 10);
+export function isReactVersionAtLeast(reactVersionToCheck) {
+    return majorVersion >= reactVersionToCheck;
+}

package/dist/internal/render/resolveClassName.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If the provided className is a string, it will be returned as is.
+ * Otherwise, the function will call the className function with the state as the first argument.
+ *
+ * @param className
+ * @param state
+ */
+export declare function resolveClassName<State>(className: string | ((state: State) => string | undefined) | undefined, state: State): string | undefined;

package/dist/internal/render/resolveClassName.js

@@ -0,0 +1,12 @@
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/utils/resolveClassName.ts
+// https://github.com/mui/base-ui — exact copy.
+/**
+ * If the provided className is a string, it will be returned as is.
+ * Otherwise, the function will call the className function with the state as the first argument.
+ *
+ * @param className
+ * @param state
+ */
+export function resolveClassName(className, state) {
+    return typeof className === 'function' ? className(state) : className;
+}

package/dist/internal/render/resolveStyle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If the provided style is an object, it will be returned as is.
+ * Otherwise, the function will call the style function with the state as the first argument.
+ *
+ * @param style
+ * @param state
+ */
+export declare function resolveStyle<State>(style: React.CSSProperties | ((state: State) => React.CSSProperties | undefined) | undefined, state: State): import("react").CSSProperties | undefined;

package/dist/internal/render/resolveStyle.js

@@ -0,0 +1,12 @@
+// Vendored from @base-ui/react v1.6.0 (MIT) — packages/react/src/utils/resolveStyle.ts
+// https://github.com/mui/base-ui — exact copy.
+/**
+ * If the provided style is an object, it will be returned as is.
+ * Otherwise, the function will call the style function with the state as the first argument.
+ *
+ * @param style
+ * @param state
+ */
+export function resolveStyle(style, state) {
+    return typeof style === 'function' ? style(state) : style;
+}