dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/avatar/root/AvatarRoot.js

@@ -0,0 +1,34 @@
+import * as React from "react";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { AvatarRootContext } from "./AvatarRootContext.js";
+import { avatarStateAttributesMapping } from "./stateAttributesMapping.js";
+import { jsx } from "react/jsx-runtime";
+const AvatarRoot = /* @__PURE__ */ React.forwardRef(function AvatarRoot2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    ...elementProps
+  } = componentProps;
+  const [imageLoadingStatus, setImageLoadingStatus] = React.useState("idle");
+  const state = {
+    imageLoadingStatus
+  };
+  const contextValue = React.useMemo(() => ({
+    imageLoadingStatus,
+    setImageLoadingStatus
+  }), [imageLoadingStatus, setImageLoadingStatus]);
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: elementProps,
+    stateAttributesMapping: avatarStateAttributesMapping
+  });
+  return /* @__PURE__ */ jsx(AvatarRootContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") AvatarRoot.displayName = "AvatarRoot";
+export {
+  AvatarRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/avatar/root/AvatarRootContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const AvatarRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") AvatarRootContext.displayName = "AvatarRootContext";
+function useAvatarRootContext() {
+  const context = React.useContext(AvatarRootContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: AvatarRootContext is missing. Avatar parts must be placed within <Avatar.Root>." : formatErrorMessage(13));
+  }
+  return context;
+}
+export {
+  AvatarRootContext,
+  useAvatarRootContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/avatar/root/stateAttributesMapping.js

@@ -0,0 +1,6 @@
+const avatarStateAttributesMapping = {
+  imageLoadingStatus: () => null
+};
+export {
+  avatarStateAttributesMapping
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/button/Button.js

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { useButton } from "../use-button/useButton.js";
+import { useRenderElement } from "../utils/useRenderElement.js";
+const Button = /* @__PURE__ */ React.forwardRef(function Button2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled = false,
+    focusableWhenDisabled = false,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    focusableWhenDisabled,
+    native: nativeButton
+  });
+  const state = {
+    disabled
+  };
+  return useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, buttonRef],
+    props: [elementProps, getButtonProps]
+  });
+});
+if (process.env.NODE_ENV !== "production") Button.displayName = "Button";
+export {
+  Button
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox/indicator/CheckboxIndicator.js

@@ -0,0 +1,58 @@
+import * as React from "react";
+import { useCheckboxRootContext } from "../root/CheckboxRootContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useStateAttributesMapping } from "../utils/useStateAttributesMapping.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { useTransitionStatus } from "../../utils/useTransitionStatus.js";
+import { transitionStatusMapping } from "../../utils/stateAttributesMapping.js";
+import { fieldValidityMapping } from "../../field/utils/constants.js";
+const CheckboxIndicator = /* @__PURE__ */ React.forwardRef(function CheckboxIndicator2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    keepMounted = false,
+    ...elementProps
+  } = componentProps;
+  const rootState = useCheckboxRootContext();
+  const rendered = rootState.checked || rootState.indeterminate;
+  const {
+    mounted,
+    transitionStatus,
+    setMounted
+  } = useTransitionStatus(rendered);
+  const indicatorRef = React.useRef(null);
+  const state = {
+    ...rootState,
+    transitionStatus
+  };
+  useOpenChangeComplete({
+    open: rendered,
+    ref: indicatorRef,
+    onComplete() {
+      if (!rendered) {
+        setMounted(false);
+      }
+    }
+  });
+  const baseStateAttributesMapping = useStateAttributesMapping(rootState);
+  const stateAttributesMapping = React.useMemo(() => ({
+    ...baseStateAttributesMapping,
+    ...transitionStatusMapping,
+    ...fieldValidityMapping
+  }), [baseStateAttributesMapping]);
+  const shouldRender = keepMounted || mounted;
+  const element = useRenderElement("span", componentProps, {
+    ref: [forwardedRef, indicatorRef],
+    state,
+    stateAttributesMapping,
+    props: elementProps
+  });
+  if (!shouldRender) {
+    return null;
+  }
+  return element;
+});
+if (process.env.NODE_ENV !== "production") CheckboxIndicator.displayName = "CheckboxIndicator";
+export {
+  CheckboxIndicator
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox/root/CheckboxRoot.js

@@ -0,0 +1,294 @@
+import * as React from "react";
+import { NOOP, EMPTY_OBJECT } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/empty.js";
+import { useControlled } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useControlled.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useMergedRefs } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useMergedRefs.js";
+import { useRefWithInit } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useRefWithInit.js";
+import { visuallyHiddenInput, visuallyHidden } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/visuallyHidden.js";
+import { useStateAttributesMapping } from "../utils/useStateAttributesMapping.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useButton } from "../../use-button/useButton.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useFieldItemContext } from "../../field/item/FieldItemContext.js";
+import { useField } from "../../field/useField.js";
+import { useFormContext } from "../../form/FormContext.js";
+import { useLabelableContext } from "../../labelable-provider/LabelableContext.js";
+import { useAriaLabelledBy } from "../../labelable-provider/useAriaLabelledBy.js";
+import { useCheckboxGroupContext } from "../../checkbox-group/CheckboxGroupContext.js";
+import { CheckboxRootContext } from "./CheckboxRootContext.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useValueChanged } from "../../utils/useValueChanged.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+import { none } from "../../utils/reason-parts.js";
+const PARENT_CHECKBOX = "data-parent";
+const CheckboxRoot = /* @__PURE__ */ React.forwardRef(function CheckboxRoot2(componentProps, forwardedRef) {
+  const {
+    checked: checkedProp,
+    className,
+    defaultChecked = false,
+    "aria-labelledby": ariaLabelledByProp,
+    disabled: disabledProp = false,
+    id: idProp,
+    indeterminate = false,
+    inputRef: inputRefProp,
+    name: nameProp,
+    onCheckedChange: onCheckedChangeProp,
+    parent = false,
+    readOnly = false,
+    render,
+    required = false,
+    uncheckedValue,
+    value: valueProp,
+    nativeButton = false,
+    ...elementProps
+  } = componentProps;
+  const {
+    clearErrors
+  } = useFormContext();
+  const {
+    disabled: rootDisabled,
+    name: fieldName,
+    setDirty,
+    setFilled,
+    setFocused,
+    setTouched,
+    state: fieldState,
+    validationMode,
+    validityData,
+    shouldValidateOnChange,
+    validation: localValidation
+  } = useFieldRootContext();
+  const fieldItemContext = useFieldItemContext();
+  const {
+    labelId,
+    controlId,
+    registerControlId,
+    getDescriptionProps
+  } = useLabelableContext();
+  const groupContext = useCheckboxGroupContext();
+  const parentContext = groupContext == null ? void 0 : groupContext.parent;
+  const isGroupedWithParent = parentContext && groupContext.allValues;
+  const disabled = rootDisabled || fieldItemContext.disabled || (groupContext == null ? void 0 : groupContext.disabled) || disabledProp;
+  const name = fieldName ?? nameProp;
+  const value = valueProp ?? name;
+  const id = useBaseUiId();
+  const parentId = useBaseUiId();
+  let inputId = controlId;
+  if (isGroupedWithParent) {
+    inputId = parent ? parentId : `${parentContext.id}-${value}`;
+  } else if (idProp) {
+    inputId = idProp;
+  }
+  let groupProps = {};
+  if (isGroupedWithParent) {
+    if (parent) {
+      groupProps = groupContext.parent.getParentProps();
+    } else if (value) {
+      groupProps = groupContext.parent.getChildProps(value);
+    }
+  }
+  const onCheckedChange = useStableCallback(onCheckedChangeProp);
+  const {
+    checked: groupChecked = checkedProp,
+    indeterminate: groupIndeterminate = indeterminate,
+    onCheckedChange: groupOnChange,
+    ...otherGroupProps
+  } = groupProps;
+  const groupValue = groupContext == null ? void 0 : groupContext.value;
+  const setGroupValue = groupContext == null ? void 0 : groupContext.setValue;
+  const defaultGroupValue = groupContext == null ? void 0 : groupContext.defaultValue;
+  const controlRef = React.useRef(null);
+  const controlSourceRef = useRefWithInit(() => Symbol("checkbox-control"));
+  const hasRegisteredRef = React.useRef(false);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const validation = (groupContext == null ? void 0 : groupContext.validation) ?? localValidation;
+  const [checked, setCheckedState] = useControlled({
+    controlled: value && groupValue && !parent ? groupValue.includes(value) : groupChecked,
+    default: value && defaultGroupValue && !parent ? defaultGroupValue.includes(value) : defaultChecked,
+    name: "Checkbox",
+    state: "checked"
+  });
+  useIsoLayoutEffect(() => {
+    if (registerControlId === NOOP) {
+      return void 0;
+    }
+    hasRegisteredRef.current = true;
+    registerControlId(controlSourceRef.current, inputId);
+    return void 0;
+  }, [inputId, groupContext, registerControlId, parent, controlSourceRef]);
+  React.useEffect(() => {
+    const controlSource = controlSourceRef.current;
+    return () => {
+      if (!hasRegisteredRef.current || registerControlId === NOOP) {
+        return;
+      }
+      hasRegisteredRef.current = false;
+      registerControlId(controlSource, void 0);
+    };
+  }, [registerControlId, controlSourceRef]);
+  useField({
+    enabled: !groupContext,
+    id,
+    commit: validation.commit,
+    value: checked,
+    controlRef,
+    name,
+    getValue: () => checked
+  });
+  const inputRef = React.useRef(null);
+  const mergedInputRef = useMergedRefs(inputRefProp, inputRef, validation.inputRef);
+  const ariaLabelledBy = useAriaLabelledBy(ariaLabelledByProp, labelId, inputRef, !nativeButton, inputId ?? void 0);
+  useIsoLayoutEffect(() => {
+    if (inputRef.current) {
+      inputRef.current.indeterminate = groupIndeterminate;
+      if (checked) {
+        setFilled(true);
+      }
+    }
+  }, [checked, groupIndeterminate, setFilled]);
+  useValueChanged(checked, () => {
+    if (groupContext && !parent) {
+      return;
+    }
+    clearErrors(name);
+    setFilled(checked);
+    setDirty(checked !== validityData.initialValue);
+    if (shouldValidateOnChange()) {
+      validation.commit(checked);
+    } else {
+      validation.commit(checked, true);
+    }
+  });
+  const inputProps = mergeProps(
+    {
+      checked,
+      disabled,
+      // parent checkboxes unset `name` to be excluded from form submission
+      name: parent ? void 0 : name,
+      // Set `id` to stop Chrome warning about an unassociated input.
+      // When using a native button, the `id` is applied to the button instead.
+      id: nativeButton ? void 0 : inputId ?? void 0,
+      required,
+      ref: mergedInputRef,
+      style: name ? visuallyHiddenInput : visuallyHidden,
+      tabIndex: -1,
+      type: "checkbox",
+      "aria-hidden": true,
+      onChange(event) {
+        if (event.nativeEvent.defaultPrevented) {
+          return;
+        }
+        const nextChecked = event.target.checked;
+        const details = createChangeEventDetails(none, event.nativeEvent);
+        groupOnChange == null ? void 0 : groupOnChange(nextChecked, details);
+        onCheckedChange(nextChecked, details);
+        if (details.isCanceled) {
+          return;
+        }
+        setCheckedState(nextChecked);
+        if (value && groupValue && setGroupValue && !parent) {
+          const nextGroupValue = nextChecked ? [...groupValue, value] : groupValue.filter((item) => item !== value);
+          setGroupValue(nextGroupValue, details);
+        }
+      },
+      onFocus() {
+        var _a;
+        (_a = controlRef.current) == null ? void 0 : _a.focus();
+      }
+    },
+    // React <19 sets an empty value if `undefined` is passed explicitly
+    // To avoid this, we only set the value if it's defined
+    valueProp !== void 0 ? {
+      value: (groupContext ? checked && valueProp : valueProp) || ""
+    } : EMPTY_OBJECT,
+    getDescriptionProps,
+    groupContext ? validation.getValidationProps : validation.getInputValidationProps
+  );
+  const computedChecked = isGroupedWithParent ? Boolean(groupChecked) : checked;
+  const computedIndeterminate = isGroupedWithParent ? groupIndeterminate || indeterminate : indeterminate;
+  React.useEffect(() => {
+    if (!parentContext || !value) {
+      return void 0;
+    }
+    const disabledStates = parentContext.disabledStatesRef.current;
+    disabledStates.set(value, disabled);
+    return () => {
+      disabledStates.delete(value);
+    };
+  }, [parentContext, disabled, value]);
+  const state = React.useMemo(() => ({
+    ...fieldState,
+    checked: computedChecked,
+    disabled,
+    readOnly,
+    required,
+    indeterminate: computedIndeterminate
+  }), [fieldState, computedChecked, disabled, readOnly, required, computedIndeterminate]);
+  const stateAttributesMapping = useStateAttributesMapping(state);
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: [buttonRef, controlRef, forwardedRef, groupContext == null ? void 0 : groupContext.registerControlRef],
+    props: [{
+      id: nativeButton ? inputId ?? void 0 : id,
+      role: "checkbox",
+      "aria-checked": groupIndeterminate ? "mixed" : checked,
+      "aria-readonly": readOnly || void 0,
+      "aria-required": required || void 0,
+      "aria-labelledby": ariaLabelledBy,
+      [PARENT_CHECKBOX]: parent ? "" : void 0,
+      onFocus() {
+        setFocused(true);
+      },
+      onBlur() {
+        const inputEl = inputRef.current;
+        if (!inputEl) {
+          return;
+        }
+        setTouched(true);
+        setFocused(false);
+        if (validationMode === "onBlur") {
+          validation.commit(groupContext ? groupValue : inputEl.checked);
+        }
+      },
+      onClick(event) {
+        var _a;
+        if (readOnly || disabled) {
+          return;
+        }
+        event.preventDefault();
+        (_a = inputRef.current) == null ? void 0 : _a.dispatchEvent(new PointerEvent("click", {
+          bubbles: true,
+          shiftKey: event.shiftKey,
+          ctrlKey: event.ctrlKey,
+          altKey: event.altKey,
+          metaKey: event.metaKey
+        }));
+      }
+    }, getDescriptionProps, validation.getValidationProps, elementProps, otherGroupProps, getButtonProps],
+    stateAttributesMapping
+  });
+  return /* @__PURE__ */ jsxs(CheckboxRootContext.Provider, {
+    value: state,
+    children: [element, !checked && !groupContext && name && !parent && uncheckedValue !== void 0 && /* @__PURE__ */ jsx("input", {
+      type: "hidden",
+      name,
+      value: uncheckedValue
+    }), /* @__PURE__ */ jsx("input", {
+      ...inputProps
+    })]
+  });
+});
+if (process.env.NODE_ENV !== "production") CheckboxRoot.displayName = "CheckboxRoot";
+export {
+  CheckboxRoot,
+  PARENT_CHECKBOX
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox/root/CheckboxRootContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const CheckboxRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") CheckboxRootContext.displayName = "CheckboxRootContext";
+function useCheckboxRootContext() {
+  const context = React.useContext(CheckboxRootContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CheckboxRootContext is missing. Checkbox parts must be placed within <Checkbox.Root>." : formatErrorMessage(14));
+  }
+  return context;
+}
+export {
+  CheckboxRootContext,
+  useCheckboxRootContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox/root/CheckboxRootDataAttributes.js

@@ -0,0 +1,18 @@
+let CheckboxRootDataAttributes = /* @__PURE__ */ function(CheckboxRootDataAttributes2) {
+  CheckboxRootDataAttributes2["checked"] = "data-checked";
+  CheckboxRootDataAttributes2["unchecked"] = "data-unchecked";
+  CheckboxRootDataAttributes2["indeterminate"] = "data-indeterminate";
+  CheckboxRootDataAttributes2["disabled"] = "data-disabled";
+  CheckboxRootDataAttributes2["readonly"] = "data-readonly";
+  CheckboxRootDataAttributes2["required"] = "data-required";
+  CheckboxRootDataAttributes2["valid"] = "data-valid";
+  CheckboxRootDataAttributes2["invalid"] = "data-invalid";
+  CheckboxRootDataAttributes2["touched"] = "data-touched";
+  CheckboxRootDataAttributes2["dirty"] = "data-dirty";
+  CheckboxRootDataAttributes2["filled"] = "data-filled";
+  CheckboxRootDataAttributes2["focused"] = "data-focused";
+  return CheckboxRootDataAttributes2;
+}({});
+export {
+  CheckboxRootDataAttributes
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox/utils/useStateAttributesMapping.js

@@ -0,0 +1,24 @@
+import * as React from "react";
+import { CheckboxRootDataAttributes } from "../root/CheckboxRootDataAttributes.js";
+import { fieldValidityMapping } from "../../field/utils/constants.js";
+function useStateAttributesMapping(state) {
+  return React.useMemo(() => ({
+    checked(value) {
+      if (state.indeterminate) {
+        return {};
+      }
+      if (value) {
+        return {
+          [CheckboxRootDataAttributes.checked]: ""
+        };
+      }
+      return {
+        [CheckboxRootDataAttributes.unchecked]: ""
+      };
+    },
+    ...fieldValidityMapping
+  }), [state.indeterminate]);
+}
+export {
+  useStateAttributesMapping
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/checkbox-group/CheckboxGroupContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const CheckboxGroupContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") CheckboxGroupContext.displayName = "CheckboxGroupContext";
+function useCheckboxGroupContext(optional = true) {
+  const context = React.useContext(CheckboxGroupContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CheckboxGroupContext is missing. CheckboxGroup parts must be placed within <CheckboxGroup>." : formatErrorMessage(3));
+  }
+  return context;
+}
+export {
+  CheckboxGroupContext,
+  useCheckboxGroupContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/collapsible/panel/CollapsiblePanel.js

@@ -0,0 +1,126 @@
+import * as React from "react";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { warn } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/warn.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useCollapsibleRootContext } from "../root/CollapsibleRootContext.js";
+import { collapsibleStateAttributesMapping } from "../root/stateAttributesMapping.js";
+import { useCollapsiblePanel } from "./useCollapsiblePanel.js";
+import { CollapsiblePanelCssVars } from "./CollapsiblePanelCssVars.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+const CollapsiblePanel = /* @__PURE__ */ React.forwardRef(function CollapsiblePanel2(componentProps, forwardedRef) {
+  const {
+    className,
+    hiddenUntilFound: hiddenUntilFoundProp,
+    keepMounted: keepMountedProp,
+    render,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  if (process.env.NODE_ENV !== "production") {
+    useIsoLayoutEffect(() => {
+      if (hiddenUntilFoundProp && keepMountedProp === false) {
+        warn("The `keepMounted={false}` prop on a Collapsible will be ignored when using `hiddenUntilFound` since it requires the Panel to remain mounted even when closed.");
+      }
+    }, [hiddenUntilFoundProp, keepMountedProp]);
+  }
+  const {
+    abortControllerRef,
+    animationTypeRef,
+    height,
+    mounted,
+    onOpenChange,
+    open,
+    panelId,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setHiddenUntilFound,
+    setKeepMounted,
+    setMounted,
+    setPanelIdState,
+    setOpen,
+    setVisible,
+    state,
+    transitionDimensionRef,
+    visible,
+    width,
+    transitionStatus
+  } = useCollapsibleRootContext();
+  const hiddenUntilFound = hiddenUntilFoundProp ?? false;
+  const keepMounted = keepMountedProp ?? false;
+  useIsoLayoutEffect(() => {
+    if (idProp) {
+      setPanelIdState(idProp);
+      return () => {
+        setPanelIdState(void 0);
+      };
+    }
+    return void 0;
+  }, [idProp, setPanelIdState]);
+  useIsoLayoutEffect(() => {
+    setHiddenUntilFound(hiddenUntilFound);
+  }, [setHiddenUntilFound, hiddenUntilFound]);
+  useIsoLayoutEffect(() => {
+    setKeepMounted(keepMounted);
+  }, [setKeepMounted, keepMounted]);
+  const {
+    props
+  } = useCollapsiblePanel({
+    abortControllerRef,
+    animationTypeRef,
+    externalRef: forwardedRef,
+    height,
+    hiddenUntilFound,
+    id: panelId,
+    keepMounted,
+    mounted,
+    onOpenChange,
+    open,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setMounted,
+    setOpen,
+    setVisible,
+    transitionDimensionRef,
+    visible,
+    width
+  });
+  useOpenChangeComplete({
+    open: open && transitionStatus === "idle",
+    ref: panelRef,
+    onComplete() {
+      if (!open) {
+        return;
+      }
+      setDimensions({
+        height: void 0,
+        width: void 0
+      });
+    }
+  });
+  const panelState = React.useMemo(() => ({
+    ...state,
+    transitionStatus
+  }), [state, transitionStatus]);
+  const element = useRenderElement("div", componentProps, {
+    state: panelState,
+    ref: [forwardedRef, panelRef],
+    props: [props, {
+      style: {
+        [CollapsiblePanelCssVars.collapsiblePanelHeight]: height === void 0 ? "auto" : `${height}px`,
+        [CollapsiblePanelCssVars.collapsiblePanelWidth]: width === void 0 ? "auto" : `${width}px`
+      }
+    }, elementProps],
+    stateAttributesMapping: collapsibleStateAttributesMapping
+  });
+  const shouldRender = keepMounted || hiddenUntilFound || !keepMounted && mounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return element;
+});
+if (process.env.NODE_ENV !== "production") CollapsiblePanel.displayName = "CollapsiblePanel";
+export {
+  CollapsiblePanel
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/collapsible/panel/CollapsiblePanelCssVars.js

@@ -0,0 +1,8 @@
+let CollapsiblePanelCssVars = /* @__PURE__ */ function(CollapsiblePanelCssVars2) {
+  CollapsiblePanelCssVars2["collapsiblePanelHeight"] = "--collapsible-panel-height";
+  CollapsiblePanelCssVars2["collapsiblePanelWidth"] = "--collapsible-panel-width";
+  return CollapsiblePanelCssVars2;
+}({});
+export {
+  CollapsiblePanelCssVars
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/collapsible/panel/CollapsiblePanelDataAttributes.js

@@ -0,0 +1,11 @@
+import { TransitionStatusDataAttributes } from "../../utils/stateAttributesMapping.js";
+let CollapsiblePanelDataAttributes = function(CollapsiblePanelDataAttributes2) {
+  CollapsiblePanelDataAttributes2["open"] = "data-open";
+  CollapsiblePanelDataAttributes2["closed"] = "data-closed";
+  CollapsiblePanelDataAttributes2[CollapsiblePanelDataAttributes2["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
+  CollapsiblePanelDataAttributes2[CollapsiblePanelDataAttributes2["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
+  return CollapsiblePanelDataAttributes2;
+}({});
+export {
+  CollapsiblePanelDataAttributes
+};