@intentface/ui 0.0.0 → 0.7.0

package/dist/internal/collection.js

@@ -0,0 +1,72 @@
+/**
+ * List maths for an ordered, mutable collection.
+ *
+ * Base UI derives collection order from the DOM, walking
+ * `compareDocumentPosition`, because its collections are declarative children.
+ * Ours are not: the order is an array of ids on the store, so order is *data*
+ * and none of that machinery is needed. What is left is arithmetic, which is
+ * pure and therefore easy to be sure about.
+ */
+/**
+ * Which item to land on when `removed` leaves the collection.
+ *
+ * The item that slides into the vacated slot, or the last one if the tail was
+ * removed — the same thing an editor does when you close a tab, and the
+ * closest thing to "stay where you were".
+ */
+export const adjacentTo = (items, removed, 
+/** Skips anything it rejects, searching outwards from the vacated slot. */
+isEligible = () => true) => {
+    const index = items.indexOf(removed);
+    if (index === -1)
+        return null;
+    const remaining = items.filter((item) => item !== removed && isEligible(item));
+    if (remaining.length === 0)
+        return null;
+    // Everything that was after it, then everything before it, nearest first.
+    const after = items.slice(index + 1).find((item) => remaining.includes(item));
+    if (after !== undefined)
+        return after;
+    const before = items
+        .slice(0, index)
+        .reverse()
+        .find((item) => remaining.includes(item));
+    return before ?? null;
+};
+/**
+ * Step one place through the collection.
+ *
+ * From nothing, arrive at whichever end you are heading away from. At an edge,
+ * either wrap or stay put.
+ */
+export const step = (items, from, direction, { loop = true } = {}) => {
+    const last = items.length - 1;
+    if (last < 0)
+        return null;
+    const index = from === null ? -1 : items.indexOf(from);
+    if (index === -1)
+        return (direction === 1 ? items[0] : items[last]) ?? null;
+    const next = index + direction;
+    if (next < 0)
+        return (loop ? items[last] : items[0]) ?? null;
+    if (next > last)
+        return (loop ? items[0] : items[last]) ?? null;
+    return items[next] ?? null;
+};
+/** Move an item to a new position, clamping the target into range. */
+export const moveTo = (items, id, toIndex) => {
+    const from = items.indexOf(id);
+    if (from === -1)
+        return items;
+    const without = items.filter((item) => item !== id);
+    const target = Math.min(Math.max(toIndex, 0), without.length);
+    return [...without.slice(0, target), id, ...without.slice(target)];
+};
+/** Insert an item, or move it if it is already present. Defaults to the end. */
+export const insertAt = (items, id, index) => {
+    const without = items.filter((item) => item !== id);
+    if (index === undefined)
+        return [...without, id];
+    const target = Math.min(Math.max(index, 0), without.length);
+    return [...without.slice(0, target), id, ...without.slice(target)];
+};

package/dist/internal/iso-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/internal/iso-layout-effect.js

@@ -0,0 +1,6 @@
+"use client";
+import { useEffect, useLayoutEffect } from "react";
+// SSR-safe layout effect. There is no layout to read on the server, so it
+// degrades to useEffect there; on the client it still runs before paint, which
+// is the whole point for anything that measures or corrects the DOM.
+export const useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;

package/dist/internal/portal.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+export type PortalProps = {
+    children?: ReactNode;
+    container?: Element | null;
+};
+export declare const Portal: ({ children, container }: PortalProps) => import("react").ReactPortal | null;

package/dist/internal/portal.js

@@ -0,0 +1,18 @@
+"use client";
+import { useSyncExternalStore } from "react";
+import { createPortal } from "react-dom";
+// The one way the package portals. A portal can't be server-rendered — there is
+// no document to portal into — so the first client render must stay empty too,
+// or hydration won't match. useSyncExternalStore renders the server snapshot
+// (false) while hydrating and re-renders with the client one right after; a
+// client-only mount gets true straight away.
+const getSnapshot = () => true;
+const getServerSnapshot = () => false;
+const subscribe = () => () => { };
+const useHydrated = () => useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+export const Portal = ({ children, container }) => {
+    const hydrated = useHydrated();
+    if (!hydrated)
+        return null;
+    return createPortal(children, container ?? document.body);
+};

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

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

package/dist/internal/primitive-props.js

@@ -0,0 +1,3 @@
+// Alias over the vendored render machinery's component-props type. 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 PreventableEvent<E extends React.SyntheticEvent<Element, Event>> = E & {
+    preventPrimitiveHandler: () => void;
+    readonly primitiveHandlerPrevented?: 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 upstream event-details re-export is
+// dropped (unused by the render machinery) and names made neutral; 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.js';
+/**
+ * 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 { PreventableEvent, WithPreventableEvents } from './types.js';
+type ElementType = React.ElementType;
+type PropsOf<T extends React.ElementType> = WithPreventableEvents<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.preventPrimitiveHandler()`. 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 `preventPrimitiveHandler` is called.
+ * They must check `event.primitiveHandlerPrevented` 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: PreventableEvent<T>): PreventableEvent<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 — import specifiers rewired and names made neutral; otherwise an exact copy.
+import * as React from 'react';
+import { mergeObjects } from './mergeObjects.js';
+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 preventableEvent = event;
+            makeEventPreventable(preventableEvent);
+            const result = theirHandler(...args);
+            if (!preventableEvent.primitiveHandlerPrevented) {
+                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.preventPrimitiveHandler = () => {
+        event.primitiveHandlerPrevented = 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,33 @@
+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;
+    /**
+     * Called with the resolved placement every time one lands — which is what flip and shift may
+     * have changed it to, not necessarily what was asked for. Fires on every reposition, so a
+     * caller holding it in state must compare before setting. Until the first call the surface has
+     * no left/top, so a consumer that transitions those should withhold paint rather than animate
+     * in from 0,0.
+     */
+    onPositioned?: (placement: {
+        side: AnchorSide;
+        align: AnchorAlign;
+    }) => void;
+};
+export declare const useAnchorPositioning: (getAnchor: () => Element | null, floatingRef: RefObject<HTMLElement | null>, { enabled, side, align, sideOffset, collisionPadding, pin, onPositioned, }?: UseAnchorPositioningOptions) => void;

package/dist/internal/render/positioning.js

@@ -0,0 +1,112 @@
+"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` / `--anchor-available-width` (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, onPositioned, } = {}) => {
+    useEffect(() => {
+        const floating = floatingRef.current;
+        if (!enabled || !floating)
+            return;
+        const placement = (align === "center" ? side : `${side}-${align}`);
+        // Out of flow *before* anything is measured. A static element portaled into a flex or
+        // grid container is a layout participant, and a 500px participant shoves its siblings —
+        // including the anchor — somewhere else for exactly the measurement that matters.
+        floating.style.position = "absolute";
+        // Withhold paint until the first placement lands, since until then the surface has no
+        // left/top and would otherwise show at 0,0 for a frame — and a consumer transitioning
+        // left/top would animate it in from the corner (`auto` → a length is not interpolable).
+        // `data-side` is written below and by nothing else, so its absence means "never placed".
+        if (!floating.hasAttribute("data-side")) {
+            floating.style.visibility = "hidden";
+        }
+        // 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 = () => {
+            // The first placement must land, not animate: a consumer transitioning
+            // left/top would otherwise slide the surface in from wherever the browser
+            // had it before there were coordinates at all.
+            const firstPlacement = !floating.hasAttribute("data-side");
+            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({ availableWidth, 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`);
+                            floating.style.setProperty("--anchor-available-width", `${Math.max(0, Math.round(availableWidth))}px`);
+                        },
+                    }),
+                ],
+            }).then(({ x, y, placement: resolved }) => {
+                if (firstPlacement)
+                    floating.style.transition = "none";
+                floating.style.position = "absolute";
+                floating.style.left = `${Math.round(x)}px`;
+                floating.style.top = `${Math.round(y)}px`;
+                // Placed, so it may paint. Cleared rather than set to "visible", which would override
+                // a consumer hiding it for its own reasons.
+                floating.style.visibility = "";
+                const [resolvedSide = side, resolvedAlign = "center"] = resolved.split("-");
+                floating.setAttribute("data-side", resolvedSide);
+                floating.setAttribute("data-align", resolvedAlign);
+                onPositioned?.({
+                    side: resolvedSide,
+                    align: resolvedAlign,
+                });
+                // Flush the first coordinates into computed style while transitions are off, then
+                // hand the property back. A deferred restore (rAF) is not enough: rAF callbacks run
+                // *before* the frame's style recalc, so the recalc would still see `auto → x` with
+                // the consumer's transition live and animate it in from the static position.
+                if (firstPlacement) {
+                    void floating.offsetHeight;
+                    floating.style.transition = "";
+                }
+            });
+        };
+        return autoUpdate(reference, floating, update);
+    }, [enabled, getAnchor, floatingRef, side, align, sideOffset, collisionPadding, pin, onPositioned]);
+};

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;
+}