@wix/site-ui 1.30.0 → 1.32.0

package/dist/Toolbar/index.d.ts

@@ -1,33 +1,302 @@
 import * as React_2 from 'react';
-import { ToolbarButtonProps } from '@base-ui/react/toolbar';
-import { ToolbarGroupProps } from '@base-ui/react/toolbar';
-import { ToolbarInputProps } from '@base-ui/react/toolbar';
-import { ToolbarLinkProps } from '@base-ui/react/toolbar';
-import { ToolbarRootProps } from '@base-ui/react/toolbar';
-import { ToolbarSeparatorProps } from '@base-ui/react/toolbar';
+import { ToolbarButtonProps as ToolbarButtonProps_2 } from '@base-ui/react/toolbar';
+import { ToolbarGroupProps as ToolbarGroupProps_2 } from '@base-ui/react/toolbar';
+import { ToolbarInputProps as ToolbarInputProps_2 } from '@base-ui/react/toolbar';
+import { ToolbarLinkProps as ToolbarLinkProps_2 } from '@base-ui/react/toolbar';
+import { ToolbarRootProps as ToolbarRootProps_2 } from '@base-ui/react/toolbar';
+import { ToolbarSeparatorProps as ToolbarSeparatorProps_2 } from '@base-ui/react/toolbar';
+
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | 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.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare interface NativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `false` if the rendered element is not a button (for example, `<div>`).
+     * @default true
+     */
+    nativeButton?: boolean | undefined;
+}
+
+export declare type Orientation = 'horizontal' | 'vertical';
+
+/**
+ * A separator element accessible to screen readers.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Separator](https://base-ui.com/react/components/separator)
+ */
+declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace Separator {
+    type Props = SeparatorProps;
+    type State = SeparatorState;
+}
+
+declare interface SeparatorProps extends BaseUIComponentProps<'div', SeparatorState> {
+    /**
+     * The orientation of the separator.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation | undefined;
+}
+
+declare interface SeparatorState {
+    /**
+     * The orientation of the separator.
+     */
+    orientation: Orientation;
+}
 
 export declare const Toolbar: {
-    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarRootProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarRootProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Group: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarGroupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Group: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarGroupProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Button: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarButtonProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
+    Button: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarButtonProps_2, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLButtonElement>>;
-    Link: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarLinkProps, "ref"> & React_2.RefAttributes<HTMLAnchorElement>, "ref">, "className"> & {
+    Link: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarLinkProps_2, "ref"> & React_2.RefAttributes<HTMLAnchorElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLAnchorElement>>;
-    Input: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarInputProps, "ref"> & React_2.RefAttributes<HTMLInputElement>, "ref">, "className"> & {
+    Input: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarInputProps_2, "ref"> & React_2.RefAttributes<HTMLInputElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLInputElement>>;
-    Separator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarSeparatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Separator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ToolbarSeparatorProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
 };
 
+/**
+ * A button that can be used as-is or as a trigger for other components.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarButton: React_2.ForwardRefExoticComponent<Omit<ToolbarButtonProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare namespace ToolbarButton {
+    export type State = ToolbarButtonState;
+    export type Props = ToolbarButtonProps;
+}
+
+export declare interface ToolbarButtonProps extends NativeButtonProps, BaseUIComponentProps<'button', ToolbarButtonState> {
+    /**
+     * When `true` the item is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * When `true` the item remains focusable when disabled.
+     * @default true
+     */
+    focusableWhenDisabled?: boolean | undefined;
+}
+
+export declare interface ToolbarButtonState extends ToolbarRootState {
+    /**
+     * Whether the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the component remains focusable when disabled.
+     */
+    focusable: boolean;
+}
+
+/**
+ * Groups several toolbar items or toggles.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarGroup: React_2.ForwardRefExoticComponent<Omit<ToolbarGroupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ToolbarGroup {
+    export type State = ToolbarGroupState;
+    export type Props = ToolbarGroupProps;
+}
+
+export declare interface ToolbarGroupProps extends BaseUIComponentProps<'div', ToolbarGroupState> {
+    /**
+     * When `true` all toolbar items in the group are disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+}
+
+export declare interface ToolbarGroupState extends ToolbarRootState {}
+
+/**
+ * A native input element that integrates with Toolbar keyboard navigation.
+ * Renders an `<input>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarInput: React_2.ForwardRefExoticComponent<Omit<ToolbarInputProps, "ref"> & React_2.RefAttributes<HTMLInputElement>>;
+
+export declare namespace ToolbarInput {
+    export type State = ToolbarInputState;
+    export type Props = ToolbarInputProps;
+}
+
+export declare interface ToolbarInputProps extends BaseUIComponentProps<'input', ToolbarInputState> {
+    /**
+     * When `true` the item is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * When `true` the item remains focusable when disabled.
+     * @default true
+     */
+    focusableWhenDisabled?: boolean | undefined;
+    defaultValue?: React_2.ComponentProps<'input'>['defaultValue'] | undefined;
+}
+
+export declare interface ToolbarInputState extends ToolbarRootState {
+    /**
+     * Whether the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the component remains focusable when disabled.
+     */
+    focusable: boolean;
+}
+
+/**
+ * A link component.
+ * Renders an `<a>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarLink: React_2.ForwardRefExoticComponent<Omit<ToolbarLinkProps, "ref"> & React_2.RefAttributes<HTMLAnchorElement>>;
+
+export declare namespace ToolbarLink {
+    export type State = ToolbarLinkState;
+    export type Props = ToolbarLinkProps;
+}
+
+export declare interface ToolbarLinkProps extends BaseUIComponentProps<'a', ToolbarLinkState> {}
+
+export declare interface ToolbarLinkState {
+    /**
+     * The component orientation.
+     */
+    orientation: ToolbarRoot.Orientation;
+}
+
+/**
+ * A container for grouping a set of controls, such as buttons, toggle groups, or menus.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarRoot: React_2.ForwardRefExoticComponent<Omit<ToolbarRootProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ToolbarRoot {
+    export type ItemMetadata = ToolbarRootItemMetadata;
+    export type Orientation = ToolbarRootOrientation;
+    export type State = ToolbarRootState;
+    export type Props = ToolbarRootProps;
+}
+
+export declare interface ToolbarRootItemMetadata {
+    focusableWhenDisabled: boolean;
+}
+
+export declare type ToolbarRootOrientation = Orientation;
+
+export declare interface ToolbarRootProps extends BaseUIComponentProps<'div', ToolbarRootState> {
+    disabled?: boolean | undefined;
+    /**
+     * The orientation of the toolbar.
+     * @default 'horizontal'
+     */
+    orientation?: ToolbarRoot.Orientation | undefined;
+    /**
+     * If `true`, using keyboard navigation will wrap focus to the other end of the toolbar once the end is reached.
+     *
+     * @default true
+     */
+    loopFocus?: boolean | undefined;
+}
+
+export declare interface ToolbarRootState {
+    /**
+     * Whether the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * The component orientation.
+     */
+    orientation: ToolbarRoot.Orientation;
+}
+
+/**
+ * A separator element accessible to screen readers.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Toolbar](https://base-ui.com/react/components/toolbar)
+ */
+export declare const ToolbarSeparator: React_2.ForwardRefExoticComponent<Omit<ToolbarSeparatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ToolbarSeparator {
+    export type State = ToolbarSeparatorState;
+    export type Props = ToolbarSeparatorProps;
+}
+
+export declare interface ToolbarSeparatorProps extends BaseUIComponentProps<'div', ToolbarSeparatorState>, Separator.Props {}
+
+export declare interface ToolbarSeparatorState extends SeparatorState {}
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
 
-export * from "@base-ui/react/toolbar";
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
 export { }

package/dist/Toolbar/index.js

@@ -1,44 +1,265 @@
 import { jsx } from "react/jsx-runtime";
-import { Toolbar } from "@base-ui/react/toolbar";
 import clsx from "clsx";
+import { ToolbarRootContext, useToolbarRootContext } from "../6107.js";
+import { CompositeRoot } from "../9087.js";
+import { useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { useFocusableWhenDisabled, useButton } from "../9189.js";
+import { CompositeItem } from "../951.js";
+import { ARROW_LEFT, ARROW_RIGHT } from "../1500.js";
+import { stopEvent } from "../6330.js";
+import { Separator as Separator_Separator } from "../9635.js";
 import * as __rspack_external_react from "react";
+const ToolbarRoot_ToolbarRoot = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { disabled = false, loopFocus = true, orientation = 'horizontal', className, render, style, ...elementProps } = componentProps;
+    const [itemMap, setItemMap] = __rspack_external_react.useState(()=>new Map());
+    const disabledIndices = __rspack_external_react.useMemo(()=>{
+        const output = [];
+        for (const itemMetadata of itemMap.values())if (itemMetadata?.index && !itemMetadata.focusableWhenDisabled) output.push(itemMetadata.index);
+        return output;
+    }, [
+        itemMap
+    ]);
+    const toolbarRootContext = __rspack_external_react.useMemo(()=>({
+            disabled,
+            orientation,
+            setItemMap
+        }), [
+        disabled,
+        orientation,
+        setItemMap
+    ]);
+    const state = {
+        disabled,
+        orientation
+    };
+    const defaultProps = {
+        'aria-orientation': orientation,
+        role: 'toolbar'
+    };
+    return /*#__PURE__*/ jsx(ToolbarRootContext.Provider, {
+        value: toolbarRootContext,
+        children: /*#__PURE__*/ jsx(CompositeRoot, {
+            render: render,
+            className: className,
+            style: style,
+            state: state,
+            refs: [
+                forwardedRef
+            ],
+            props: [
+                defaultProps,
+                elementProps
+            ],
+            disabledIndices: disabledIndices,
+            loopFocus: loopFocus,
+            onMapChange: setItemMap,
+            orientation: orientation
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarRoot_ToolbarRoot.displayName = "ToolbarRoot";
+const ToolbarGroupContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ToolbarGroupContext.displayName = "ToolbarGroupContext";
+function useToolbarGroupContext(optional) {
+    const context = __rspack_external_react.useContext(ToolbarGroupContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ToolbarGroupContext is missing. ToolbarGroup parts must be placed within <Toolbar.Group>.' : esm_formatErrorMessage(68));
+    return context;
+}
+const ToolbarGroup_ToolbarGroup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, disabled: disabledProp = false, render, style, ...elementProps } = componentProps;
+    const { orientation, disabled: toolbarDisabled } = useToolbarRootContext();
+    const disabled = toolbarDisabled || disabledProp;
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            disabled
+        }), [
+        disabled
+    ]);
+    const state = {
+        disabled,
+        orientation
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                role: 'group'
+            },
+            elementProps
+        ]
+    });
+    return /*#__PURE__*/ jsx(ToolbarGroupContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarGroup_ToolbarGroup.displayName = "ToolbarGroup";
+const ToolbarButton_ToolbarButton = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, disabled: disabledProp = false, focusableWhenDisabled = true, render, nativeButton = true, style, ...elementProps } = componentProps;
+    const itemMetadata = __rspack_external_react.useMemo(()=>({
+            focusableWhenDisabled
+        }), [
+        focusableWhenDisabled
+    ]);
+    const { disabled: toolbarDisabled, orientation } = useToolbarRootContext();
+    const groupContext = useToolbarGroupContext(true);
+    const disabled = toolbarDisabled || (groupContext?.disabled ?? false) || disabledProp;
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled,
+        native: nativeButton
+    });
+    const state = {
+        disabled,
+        orientation,
+        focusable: focusableWhenDisabled
+    };
+    return /*#__PURE__*/ jsx(CompositeItem, {
+        tag: "button",
+        render: render,
+        className: className,
+        style: style,
+        metadata: itemMetadata,
+        state: state,
+        refs: [
+            forwardedRef,
+            buttonRef
+        ],
+        props: [
+            elementProps,
+            {
+                disabled
+            },
+            getButtonProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarButton_ToolbarButton.displayName = "ToolbarButton";
+const TOOLBAR_LINK_METADATA = {
+    focusableWhenDisabled: true
+};
+const ToolbarLink_ToolbarLink = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, render, style, ...elementProps } = componentProps;
+    const { orientation } = useToolbarRootContext();
+    const state = {
+        orientation
+    };
+    return /*#__PURE__*/ jsx(CompositeItem, {
+        tag: "a",
+        render: render,
+        className: className,
+        style: style,
+        metadata: TOOLBAR_LINK_METADATA,
+        state: state,
+        refs: [
+            forwardedRef
+        ],
+        props: [
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarLink_ToolbarLink.displayName = "ToolbarLink";
+const ToolbarInput_ToolbarInput = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, focusableWhenDisabled = true, render, disabled: disabledProp = false, style, ...elementProps } = componentProps;
+    const itemMetadata = __rspack_external_react.useMemo(()=>({
+            focusableWhenDisabled
+        }), [
+        focusableWhenDisabled
+    ]);
+    const { disabled: toolbarDisabled, orientation } = useToolbarRootContext();
+    const groupContext = useToolbarGroupContext(true);
+    const disabled = toolbarDisabled || (groupContext?.disabled ?? false) || disabledProp;
+    const { props: focusableWhenDisabledProps } = useFocusableWhenDisabled({
+        composite: true,
+        disabled,
+        focusableWhenDisabled,
+        isNativeButton: false
+    });
+    const state = {
+        disabled,
+        orientation,
+        focusable: focusableWhenDisabled
+    };
+    const defaultProps = {
+        onClick (event) {
+            if (disabled) event.preventDefault();
+        },
+        onKeyDown (event) {
+            if (event.key !== ARROW_LEFT && event.key !== ARROW_RIGHT && disabled) stopEvent(event);
+        },
+        onPointerDown (event) {
+            if (disabled) event.preventDefault();
+        }
+    };
+    return /*#__PURE__*/ jsx(CompositeItem, {
+        tag: "input",
+        render: render,
+        className: className,
+        style: style,
+        metadata: itemMetadata,
+        state: state,
+        refs: [
+            forwardedRef
+        ],
+        props: [
+            defaultProps,
+            elementProps,
+            focusableWhenDisabledProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarInput_ToolbarInput.displayName = "ToolbarInput";
+const ToolbarSeparator_ToolbarSeparator = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const context = useToolbarRootContext();
+    const orientation = {
+        vertical: 'horizontal',
+        horizontal: 'vertical'
+    }[context.orientation];
+    return /*#__PURE__*/ jsx(Separator_Separator, {
+        orientation: orientation,
+        ...props,
+        ref: forwardedRef
+    });
+});
+if ("production" !== process.env.NODE_ENV) ToolbarSeparator_ToolbarSeparator.displayName = "ToolbarSeparator";
 const Toolbar_module = {
     root: "root-TasA57",
     button: "button-VwIpOv",
     link: "link-ONsUed",
     separator: "separator-pZlgb3"
 };
-const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Root, {
+const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarRoot_ToolbarRoot, {
         ref: ref,
         className: clsx(Toolbar_module.root, className),
         ...props
     }));
-const Group = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Group, {
+const Group = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarGroup_ToolbarGroup, {
         ref: ref,
         className: clsx(Toolbar_module.group, className),
         ...props
     }));
-const Button = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Button, {
+const Button = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarButton_ToolbarButton, {
         ref: ref,
         className: clsx(Toolbar_module.button, className),
         ...props
     }));
-const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Link, {
+const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarLink_ToolbarLink, {
         ref: ref,
         className: clsx(Toolbar_module.link, className),
         ...props
     }));
-const Input = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Input, {
+const Input = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarInput_ToolbarInput, {
         ref: ref,
         className: clsx(Toolbar_module.input, className),
         ...props
     }));
-const Separator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Toolbar.Separator, {
+const Separator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ToolbarSeparator_ToolbarSeparator, {
         ref: ref,
         className: clsx(Toolbar_module.separator, className),
         ...props
     }));
-const Toolbar_Toolbar = {
+const Toolbar = {
     Root: Root,
     Group: Group,
     Button: Button,
@@ -46,4 +267,4 @@ const Toolbar_Toolbar = {
     Input: Input,
     Separator: Separator
 };
-export { Toolbar_Toolbar as Toolbar };
+export { Toolbar };