@wix/site-ui 1.30.0 → 1.32.0

package/dist/8272.js

@@ -0,0 +1,333 @@
+import * as __rspack_external_react from "react";
+const UNINITIALIZED = {};
+function useRefWithInit(init, initArg) {
+    const ref = __rspack_external_react.useRef(UNINITIALIZED);
+    if (ref.current === UNINITIALIZED) ref.current = init(initArg);
+    return ref;
+}
+function useMergedRefs(a, b, c, d) {
+    const forkRef = useRefWithInit(createForkRef).current;
+    if (didChange(forkRef, a, b, c, d)) update(forkRef, [
+        a,
+        b,
+        c,
+        d
+    ]);
+    return forkRef.callback;
+}
+function useMergedRefsN(refs) {
+    const forkRef = useRefWithInit(createForkRef).current;
+    if (didChangeN(forkRef, refs)) update(forkRef, refs);
+    return forkRef.callback;
+}
+function createForkRef() {
+    return {
+        callback: null,
+        cleanup: null,
+        refs: []
+    };
+}
+function didChange(forkRef, a, b, c, d) {
+    return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
+}
+function didChangeN(forkRef, newRefs) {
+    return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index)=>ref !== newRefs[index]);
+}
+function update(forkRef, refs) {
+    forkRef.refs = refs;
+    if (refs.every((ref)=>null == ref)) {
+        forkRef.callback = null;
+        return;
+    }
+    forkRef.callback = (instance)=>{
+        if (forkRef.cleanup) {
+            forkRef.cleanup();
+            forkRef.cleanup = null;
+        }
+        if (null != instance) {
+            const cleanupCallbacks = Array(refs.length).fill(null);
+            for(let i = 0; i < refs.length; i += 1){
+                const ref = refs[i];
+                if (null != ref) switch(typeof ref){
+                    case 'function':
+                        {
+                            const refCleanup = ref(instance);
+                            if ('function' == typeof refCleanup) cleanupCallbacks[i] = refCleanup;
+                            break;
+                        }
+                    case 'object':
+                        ref.current = instance;
+                        break;
+                    default:
+                }
+            }
+            forkRef.cleanup = ()=>{
+                for(let i = 0; i < refs.length; i += 1){
+                    const ref = refs[i];
+                    if (null != ref) switch(typeof ref){
+                        case 'function':
+                            {
+                                const cleanupCallback = cleanupCallbacks[i];
+                                if ('function' == typeof cleanupCallback) cleanupCallback();
+                                else ref(null);
+                                break;
+                            }
+                        case 'object':
+                            ref.current = null;
+                            break;
+                        default:
+                    }
+                }
+            };
+        }
+    };
+}
+function NOOP() {}
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze({});
+function createFormatErrorMessage(baseUrl, prefix) {
+    return function(code, ...args) {
+        const url = new URL(baseUrl);
+        url.searchParams.set('code', code.toString());
+        args.forEach((arg)=>url.searchParams.append('args[]', arg));
+        return `${prefix} error #${code}; visit ${url} for the full message.`;
+    };
+}
+const formatErrorMessage_formatErrorMessage = createFormatErrorMessage('https://base-ui.com/production-error', 'Base UI');
+const esm_formatErrorMessage = formatErrorMessage_formatErrorMessage;
+const majorVersion = parseInt(__rspack_external_react.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+    return majorVersion >= reactVersionToCheck;
+}
+function getReactElementRef(element) {
+    if (!/*#__PURE__*/ __rspack_external_react.isValidElement(element)) return null;
+    const reactElement = element;
+    const propsWithRef = reactElement.props;
+    return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}
+function mergeObjects(a, b) {
+    if (a && !b) return a;
+    if (!a && b) return b;
+    if (a || b) return {
+        ...a,
+        ...b
+    };
+}
+let set;
+if ('production' !== process.env.NODE_ENV) set = new Set();
+function warn(...messages) {
+    if ('production' !== process.env.NODE_ENV) {
+        const messageKey = messages.join(' ');
+        if (!set.has(messageKey)) {
+            set.add(messageKey);
+            console.warn(`Base UI: ${messageKey}`);
+        }
+    }
+}
+function getStateAttributesProps(state, customMapping) {
+    const props = {};
+    for(const key in state){
+        const value = state[key];
+        if (customMapping?.hasOwnProperty(key)) {
+            const customProps = customMapping[key](value);
+            if (null != customProps) Object.assign(props, customProps);
+            continue;
+        }
+        if (true === value) props[`data-${key.toLowerCase()}`] = '';
+        else if (value) props[`data-${key.toLowerCase()}`] = value.toString();
+    }
+    return props;
+}
+function resolveClassName(className, state) {
+    return 'function' == typeof className ? className(state) : className;
+}
+function resolveStyle(style, state) {
+    return 'function' == typeof style ? style(state) : style;
+}
+const EMPTY_PROPS = {};
+function mergeProps(a, b, c, d, e) {
+    if (!c && !d && !e && !a) return createInitialMergedProps(b);
+    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;
+}
+function mergePropsN(props) {
+    if (0 === props.length) return EMPTY_PROPS;
+    if (1 === props.length) return createInitialMergedProps(props[0]);
+    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)) 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
+    };
+    for(const propName in copiedProps){
+        const propValue = copiedProps[propName];
+        if (isEventHandler(propName, propValue)) copiedProps[propName] = wrapEventHandler(propValue);
+    }
+    return copiedProps;
+}
+function mutablyMergeInto(mergedProps, externalProps) {
+    if (!externalProps) return mergedProps;
+    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) {
+    const code0 = key.charCodeAt(0);
+    const code1 = key.charCodeAt(1);
+    const code2 = key.charCodeAt(2);
+    return 111 === code0 && 110 === code1 && code2 >= 65 && code2 <= 90 && ('function' == typeof value || void 0 === value);
+}
+function isPropsGetter(inputProps) {
+    return 'function' == typeof inputProps;
+}
+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);
+    };
+}
+function makeEventPreventable(event) {
+    event.preventBaseUIHandler = ()=>{
+        event.baseUIHandlerPrevented = true;
+    };
+    return event;
+}
+function mergeClassNames(ourClassName, theirClassName) {
+    if (theirClassName) {
+        if (ourClassName) return theirClassName + ' ' + ourClassName;
+        return theirClassName;
+    }
+    return ourClassName;
+}
+function isSyntheticEvent(event) {
+    return null != event && 'object' == typeof event && 'nativeEvent' in event;
+}
+function useRenderElement(element, componentProps, params = {}) {
+    const renderProp = componentProps.render;
+    const outProps = useRenderElementProps(componentProps, params);
+    if (false === params.enabled) return null;
+    const state = params.state ?? EMPTY_OBJECT;
+    return evaluateRenderProp(element, renderProp, outProps, state);
+}
+function useRenderElementProps(componentProps, params = {}) {
+    const { className: classNameProp, style: styleProp, render: renderProp } = componentProps;
+    const { state = EMPTY_OBJECT, ref, props, stateAttributesMapping, enabled = true } = params;
+    const className = enabled ? resolveClassName(classNameProp, state) : void 0;
+    const style = enabled ? resolveStyle(styleProp, state) : void 0;
+    const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
+    const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
+    const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+    if ("u" > typeof document) if (enabled) if (Array.isArray(ref)) outProps.ref = useMergedRefsN([
+        outProps.ref,
+        getReactElementRef(renderProp),
+        ...ref
+    ]);
+    else outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
+    else useMergedRefs(null, null);
+    if (!enabled) return EMPTY_OBJECT;
+    if (void 0 !== className) outProps.className = mergeClassNames(outProps.className, className);
+    if (void 0 !== style) outProps.style = mergeObjects(outProps.style, style);
+    return outProps;
+}
+function resolveRenderFunctionProps(props) {
+    if (Array.isArray(props)) return mergePropsN(props);
+    return mergeProps(void 0, props);
+}
+const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+const COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
+const LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
+function evaluateRenderProp(element, render, props, state) {
+    if (render) {
+        if ('function' == typeof render) {
+            if ('production' !== process.env.NODE_ENV) warnIfRenderPropLooksLikeComponent(render);
+            return render(props, state);
+        }
+        const mergedProps = mergeProps(props, render.props);
+        mergedProps.ref = props.ref;
+        let newElement = render;
+        if (newElement?.$$typeof === REACT_LAZY_TYPE) {
+            const children = __rspack_external_react.Children.toArray(render);
+            newElement = children[0];
+        }
+        if ('production' !== process.env.NODE_ENV) {
+            if (!/*#__PURE__*/ __rspack_external_react.isValidElement(newElement)) throw new Error("Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.\nA valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.\nhttps://base-ui.com/r/invalid-render-prop");
+        }
+        return /*#__PURE__*/ __rspack_external_react.cloneElement(newElement, mergedProps);
+    }
+    if (element) {
+        if ('string' == typeof element) return renderTag(element, props);
+    }
+    throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: Render element or function are not defined.' : esm_formatErrorMessage(8));
+}
+function warnIfRenderPropLooksLikeComponent(renderFn) {
+    const functionName = renderFn.name;
+    if (0 === functionName.length) return;
+    if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) return;
+    if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) return;
+    warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, 'This usually means a React component was passed directly as `render={Component}`.', 'Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.', 'If this is an intentional render callback, rename it to start with a lowercase letter.', 'Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.', 'https://base-ui.com/r/invalid-render-prop');
+}
+function renderTag(Tag, props) {
+    if ('button' === Tag) return /*#__PURE__*/ (0, __rspack_external_react.createElement)("button", {
+        type: "button",
+        ...props,
+        key: props.key
+    });
+    if ('img' === Tag) return /*#__PURE__*/ (0, __rspack_external_react.createElement)("img", {
+        alt: "",
+        ...props,
+        key: props.key
+    });
+    return /*#__PURE__*/ __rspack_external_react.createElement(Tag, props);
+}
+export { EMPTY_ARRAY, EMPTY_OBJECT, NOOP, esm_formatErrorMessage, isReactVersionAtLeast, makeEventPreventable, mergeProps, resolveStyle, useMergedRefs, useRefWithInit, useRenderElement, warn };

package/dist/8527.js

@@ -0,0 +1,58 @@
+import { error } from "./4026.js";
+import * as __rspack_external_react from "react";
+function useControlled({ controlled, default: defaultProp, name, state = 'value' }) {
+    const { current: isControlled } = __rspack_external_react.useRef(void 0 !== controlled);
+    const [valueState, setValue] = __rspack_external_react.useState(defaultProp);
+    const value = isControlled ? controlled : valueState;
+    if ('production' !== process.env.NODE_ENV) {
+        __rspack_external_react.useEffect(()=>{
+            if (isControlled !== (void 0 !== controlled)) error([
+                `A component is changing the ${isControlled ? '' : 'un'}controlled ${state} state of ${name} to be ${isControlled ? 'un' : ''}controlled.`,
+                'Elements should not switch from uncontrolled to controlled (or vice versa).',
+                `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`,
+                "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.",
+                'More info: https://fb.me/react-controlled-components'
+            ].join('\n'));
+        }, [
+            state,
+            name,
+            controlled
+        ]);
+        const { current: defaultValue } = __rspack_external_react.useRef(defaultProp);
+        __rspack_external_react.useEffect(()=>{
+            if (!isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp)) error([
+                `A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`
+            ].join('\n'));
+        }, [
+            defaultProp
+        ]);
+    }
+    const setValueIfUncontrolled = __rspack_external_react.useCallback((newValue)=>{
+        if (!isControlled) setValue(newValue);
+    }, []);
+    return [
+        value,
+        setValueIfUncontrolled
+    ];
+}
+function serializeToDevModeString(input) {
+    let nextId = 0;
+    const seen = new WeakMap();
+    try {
+        const result = JSON.stringify(input, function(key, value) {
+            if ('_owner' === key && this != null && 'object' == typeof this && '$$typeof' in this) return;
+            if ('bigint' == typeof value) return `__bigint__:${value}`;
+            if (null !== value && 'object' == typeof value) {
+                const id = seen.get(value);
+                if (void 0 !== id) return `__object__:${id}`;
+                seen.set(value, nextId);
+                nextId += 1;
+            }
+            return value;
+        });
+        return result ?? `__top__:${typeof input}`;
+    } catch  {
+        return '__unserializable__';
+    }
+}
+export { useControlled };

package/dist/8724.js

@@ -0,0 +1,10 @@
+import { esm_formatErrorMessage } from "./8272.js";
+import * as __rspack_external_react from "react";
+const CompositeRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) CompositeRootContext.displayName = "CompositeRootContext";
+function useCompositeRootContext(optional = false) {
+    const context = __rspack_external_react.useContext(CompositeRootContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>.' : esm_formatErrorMessage(16));
+    return context;
+}
+export { CompositeRootContext, useCompositeRootContext };