@stevederico/skateboard-ui 3.0.2 → 3.6.0

package/shadcn/lib/base-ui/progress.js

@@ -0,0 +1,278 @@
+/* @base-ui/react 1.4.1 — vendored (MIT — MUI Inc).
+ * Refresh: scripts/vendor-base-ui.js (see header for instructions).
+ * Do not edit by hand. */
+import {
+  formatNumberValue,
+  valueToPercent
+} from "./_chunk-tmfmrzwe.js";
+import {
+  useRegisteredLabelId
+} from "./_chunk-w68yxg9d.js";
+import {
+  useValueAsRef
+} from "./_chunk-drfb9kp2.js";
+import {
+  visuallyHidden
+} from "./_chunk-hzgetm70.js";
+import"./_chunk-8kh3xk78.js";
+import"./_chunk-n7dnqnbw.js";
+import"./_chunk-b40erthe.js";
+import {
+  useRenderElement
+} from "./_chunk-1s41sngz.js";
+import {
+  __export
+} from "./_chunk-1e6khrvm.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/index.parts.js
+var exports_index_parts = {};
+__export(exports_index_parts, {
+  Value: () => ProgressValue,
+  Track: () => ProgressTrack,
+  Root: () => ProgressRoot,
+  Label: () => ProgressLabel,
+  Indicator: () => ProgressIndicator
+});
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/root/ProgressRoot.js
+import * as React2 from "react";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/root/ProgressRootContext.js
+import * as React from "react";
+"use client";
+var ProgressRootContext = /* @__PURE__ */ React.createContext(undefined);
+if (true)
+  ProgressRootContext.displayName = "ProgressRootContext";
+function useProgressRootContext() {
+  const context = React.useContext(ProgressRootContext);
+  if (context === undefined) {
+    throw new Error("Base UI: ProgressRootContext is missing. Progress parts must be placed within <Progress.Root>.");
+  }
+  return context;
+}
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/root/ProgressRootDataAttributes.js
+var ProgressRootDataAttributes = /* @__PURE__ */ function(ProgressRootDataAttributes2) {
+  ProgressRootDataAttributes2["complete"] = "data-complete";
+  ProgressRootDataAttributes2["indeterminate"] = "data-indeterminate";
+  ProgressRootDataAttributes2["progressing"] = "data-progressing";
+  return ProgressRootDataAttributes2;
+}({});
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/root/stateAttributesMapping.js
+var progressStateAttributesMapping = {
+  status(value) {
+    if (value === "progressing") {
+      return {
+        [ProgressRootDataAttributes.progressing]: ""
+      };
+    }
+    if (value === "complete") {
+      return {
+        [ProgressRootDataAttributes.complete]: ""
+      };
+    }
+    if (value === "indeterminate") {
+      return {
+        [ProgressRootDataAttributes.indeterminate]: ""
+      };
+    }
+    return null;
+  }
+};
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/root/ProgressRoot.js
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+"use client";
+function getDefaultAriaValueText(formattedValue, value) {
+  if (value == null) {
+    return "indeterminate progress";
+  }
+  return formattedValue || `${value}%`;
+}
+var ProgressRoot = /* @__PURE__ */ React2.forwardRef(function ProgressRoot2(componentProps, forwardedRef) {
+  const {
+    format,
+    getAriaValueText = getDefaultAriaValueText,
+    locale,
+    max = 100,
+    min = 0,
+    value,
+    render,
+    className,
+    children,
+    style,
+    ...elementProps
+  } = componentProps;
+  const [labelId, setLabelId] = React2.useState();
+  const formatOptionsRef = useValueAsRef(format);
+  let status = "indeterminate";
+  if (Number.isFinite(value)) {
+    status = value === max ? "complete" : "progressing";
+  }
+  const formattedValue = formatNumberValue(value, locale, formatOptionsRef.current);
+  const state = React2.useMemo(() => ({
+    status
+  }), [status]);
+  const defaultProps = {
+    "aria-labelledby": labelId,
+    "aria-valuemax": max,
+    "aria-valuemin": min,
+    "aria-valuenow": value ?? undefined,
+    "aria-valuetext": getAriaValueText(formattedValue, value),
+    role: "progressbar",
+    children: /* @__PURE__ */ _jsxs(React2.Fragment, {
+      children: [children, /* @__PURE__ */ _jsx("span", {
+        role: "presentation",
+        style: visuallyHidden,
+        children: "x"
+      })]
+    })
+  };
+  const contextValue = React2.useMemo(() => ({
+    formattedValue,
+    max,
+    min,
+    setLabelId,
+    state,
+    status,
+    value
+  }), [formattedValue, max, min, setLabelId, state, status, value]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [defaultProps, elementProps],
+    stateAttributesMapping: progressStateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsx(ProgressRootContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (true)
+  ProgressRoot.displayName = "ProgressRoot";
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/track/ProgressTrack.js
+import * as React3 from "react";
+"use client";
+var ProgressTrack = /* @__PURE__ */ React3.forwardRef(function ProgressTrack2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    state
+  } = useProgressRootContext();
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: elementProps,
+    stateAttributesMapping: progressStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  ProgressTrack.displayName = "ProgressTrack";
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/indicator/ProgressIndicator.js
+import * as React4 from "react";
+"use client";
+var ProgressIndicator = /* @__PURE__ */ React4.forwardRef(function ProgressIndicator2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    max,
+    min,
+    value,
+    state
+  } = useProgressRootContext();
+  const percentageValue = Number.isFinite(value) && value !== null ? valueToPercent(value, min, max) : null;
+  const getStyles = React4.useCallback(() => {
+    if (percentageValue == null) {
+      return {};
+    }
+    return {
+      insetInlineStart: 0,
+      height: "inherit",
+      width: `${percentageValue}%`
+    };
+  }, [percentageValue]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      style: getStyles()
+    }, elementProps],
+    stateAttributesMapping: progressStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  ProgressIndicator.displayName = "ProgressIndicator";
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/value/ProgressValue.js
+import * as React5 from "react";
+"use client";
+var ProgressValue = /* @__PURE__ */ React5.forwardRef(function ProgressValue2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    children,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    value,
+    formattedValue,
+    state
+  } = useProgressRootContext();
+  const formattedValueArg = value == null ? "indeterminate" : formattedValue;
+  const formattedValueDisplay = value == null ? null : formattedValue;
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      "aria-hidden": true,
+      children: typeof children === "function" ? children(formattedValueArg, value) : formattedValueDisplay
+    }, elementProps],
+    stateAttributesMapping: progressStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  ProgressValue.displayName = "ProgressValue";
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/progress/label/ProgressLabel.js
+import * as React6 from "react";
+"use client";
+var ProgressLabel = /* @__PURE__ */ React6.forwardRef(function ProgressLabel2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    setLabelId,
+    state
+  } = useProgressRootContext();
+  const id = useRegisteredLabelId(idProp, setLabelId);
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      id,
+      role: "presentation"
+    }, elementProps],
+    stateAttributesMapping: progressStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  ProgressLabel.displayName = "ProgressLabel";
+export {
+  exports_index_parts as Progress
+};

package/shadcn/lib/base-ui/radio-group.js

@@ -0,0 +1,247 @@
+/* @base-ui/react 1.4.1 — vendored (MIT — MUI Inc).
+ * Refresh: scripts/vendor-base-ui.js (see header for instructions).
+ * Do not edit by hand. */
+import {
+  RadioGroupContext
+} from "./_chunk-3f31ka8n.js";
+import {
+  useFieldsetRootContext
+} from "./_chunk-c3572b5x.js";
+import {
+  CompositeRoot
+} from "./_chunk-0h5sskyw.js";
+import"./_chunk-r0vsdknk.js";
+import {
+  useFormContext,
+  useRegisterFieldControl
+} from "./_chunk-97tas84n.js";
+import {
+  fieldValidityMapping,
+  useFieldRootContext,
+  useLabelableContext
+} from "./_chunk-kfz96xv1.js";
+import"./_chunk-ds8fnpjj.js";
+import"./_chunk-vdc01ss3.js";
+import"./_chunk-p6qynd6r.js";
+import"./_chunk-20rtfsz9.js";
+import"./_chunk-wtw745qd.js";
+import {
+  useControlled
+} from "./_chunk-01rqe37g.js";
+import {
+  contains
+} from "./_chunk-atnkefgd.js";
+import {
+  SHIFT
+} from "./_chunk-qce0xt57.js";
+import"./_chunk-nya71ccw.js";
+import"./_chunk-t7j3rbpv.js";
+import {
+  useValueChanged
+} from "./_chunk-cwr896nf.js";
+import {
+  useBaseUiId
+} from "./_chunk-8kh3xk78.js";
+import"./_chunk-71zm6zgv.js";
+import"./_chunk-6xevjepc.js";
+import"./_chunk-sx6vkz01.js";
+import"./_chunk-n7dnqnbw.js";
+import {
+  useStableCallback
+} from "./_chunk-mznt6ktj.js";
+import"./_chunk-b40erthe.js";
+import"./_chunk-1s41sngz.js";
+import"./_chunk-1e6khrvm.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/radio-group/RadioGroup.js
+import * as React from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+"use client";
+var MODIFIER_KEYS = [SHIFT];
+var RadioGroup = /* @__PURE__ */ React.forwardRef(function RadioGroup2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled: disabledProp,
+    readOnly,
+    required,
+    onValueChange: onValueChangeProp,
+    value: externalValue,
+    defaultValue,
+    form,
+    name: nameProp,
+    inputRef: inputRefProp,
+    id: idProp,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    setTouched: setFieldTouched,
+    setFocused,
+    shouldValidateOnChange,
+    validationMode,
+    name: fieldName,
+    disabled: fieldDisabled,
+    state: fieldState,
+    validation,
+    setDirty,
+    setFilled,
+    validityData
+  } = useFieldRootContext();
+  const {
+    labelId
+  } = useLabelableContext();
+  const {
+    clearErrors
+  } = useFormContext();
+  const fieldsetContext = useFieldsetRootContext(true);
+  const disabled = fieldDisabled || disabledProp;
+  const name = fieldName ?? nameProp;
+  const id = useBaseUiId(idProp);
+  const [checkedValue, setCheckedValueUnwrapped] = useControlled({
+    controlled: externalValue,
+    default: defaultValue,
+    name: "RadioGroup",
+    state: "value"
+  });
+  const onValueChange = useStableCallback(onValueChangeProp);
+  const setCheckedValue = useStableCallback((value, eventDetails) => {
+    onValueChange(value, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    setCheckedValueUnwrapped(value);
+  });
+  const controlRef = React.useRef(null);
+  const groupInputRef = React.useRef(null);
+  const firstEnabledInputRef = React.useRef(null);
+  function setInputRef(hiddenInput) {
+    let cleanup = undefined;
+    if (inputRefProp) {
+      if (typeof inputRefProp === "function") {
+        cleanup = inputRefProp(hiddenInput);
+      } else {
+        inputRefProp.current = hiddenInput;
+      }
+    }
+    groupInputRef.current = hiddenInput;
+    validation.inputRef.current = hiddenInput;
+    return cleanup;
+  }
+  const registerControlRef = useStableCallback((element, isDisabled = false) => {
+    if (!element) {
+      return;
+    }
+    if (isDisabled) {
+      if (controlRef.current === element) {
+        controlRef.current = null;
+      }
+      return;
+    }
+    if (controlRef.current == null) {
+      controlRef.current = element;
+    }
+  });
+  const registerInputRef = useStableCallback((input) => {
+    if (!input || input.disabled) {
+      return;
+    }
+    if (!firstEnabledInputRef.current) {
+      firstEnabledInputRef.current = input;
+    }
+    const currentInput = groupInputRef.current;
+    if (input.checked || currentInput == null || currentInput.disabled) {
+      return setInputRef(input);
+    }
+    return;
+  });
+  const getFieldValue = useStableCallback(() => checkedValue ?? null);
+  useRegisterFieldControl(controlRef, {
+    id,
+    value: checkedValue,
+    getValue: getFieldValue
+  });
+  useValueChanged(checkedValue, () => {
+    clearErrors(name);
+    setDirty(checkedValue !== validityData.initialValue);
+    setFilled(checkedValue != null);
+    if (shouldValidateOnChange()) {
+      validation.commit(checkedValue);
+    } else {
+      validation.commit(checkedValue, true);
+    }
+    const fallbackInput = firstEnabledInputRef.current;
+    if (checkedValue == null && fallbackInput && !fallbackInput.disabled) {
+      setInputRef(fallbackInput);
+    }
+  });
+  const [touched, setTouched] = React.useState(false);
+  const ariaLabelledby = elementProps["aria-labelledby"] ?? labelId ?? fieldsetContext?.legendId;
+  const state = {
+    ...fieldState,
+    disabled: disabled ?? false,
+    required: required ?? false,
+    readOnly: readOnly ?? false
+  };
+  const contextValue = React.useMemo(() => ({
+    ...fieldState,
+    checkedValue,
+    disabled,
+    form,
+    validation,
+    name,
+    onValueChange,
+    readOnly,
+    registerControlRef,
+    registerInputRef,
+    required,
+    setCheckedValue,
+    setTouched,
+    touched
+  }), [checkedValue, disabled, form, validation, fieldState, name, onValueChange, readOnly, registerControlRef, registerInputRef, required, setCheckedValue, setTouched, touched]);
+  const defaultProps = {
+    role: "radiogroup",
+    "aria-required": required || undefined,
+    "aria-disabled": disabled || undefined,
+    "aria-readonly": readOnly || undefined,
+    "aria-labelledby": ariaLabelledby,
+    onFocus() {
+      setFocused(true);
+    },
+    onBlur(event) {
+      if (!contains(event.currentTarget, event.relatedTarget)) {
+        setFieldTouched(true);
+        setFocused(false);
+        if (validationMode === "onBlur") {
+          validation.commit(checkedValue);
+        }
+      }
+    },
+    onKeyDownCapture(event) {
+      if (event.key.startsWith("Arrow")) {
+        setFieldTouched(true);
+        setTouched(true);
+        setFocused(true);
+      }
+    }
+  };
+  return /* @__PURE__ */ _jsx(RadioGroupContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ _jsx(CompositeRoot, {
+      render,
+      className,
+      style,
+      state,
+      props: [defaultProps, validation.getValidationProps, elementProps],
+      refs: [forwardedRef],
+      stateAttributesMapping: fieldValidityMapping,
+      enableHomeAndEndKeys: false,
+      modifierKeys: MODIFIER_KEYS
+    })
+  });
+});
+if (true)
+  RadioGroup.displayName = "RadioGroup";
+export {
+  RadioGroup
+};