@stevederico/skateboard-ui 3.0.2 → 3.6.0

package/shadcn/lib/base-ui/_chunk-atnkefgd.js

@@ -0,0 +1,104 @@
+import {
+  FOCUSABLE_ATTRIBUTE,
+  TYPEABLE_SELECTOR,
+  isJSDOM
+} from "./_chunk-t7j3rbpv.js";
+import {
+  isElement,
+  isHTMLElement,
+  isShadowRoot
+} from "./_chunk-sx6vkz01.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/shadowDom.js
+function activeElement(doc) {
+  let element = doc.activeElement;
+  while (element?.shadowRoot?.activeElement != null) {
+    element = element.shadowRoot.activeElement;
+  }
+  return element;
+}
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode?.();
+  if (parent.contains(child)) {
+    return true;
+  }
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getTarget(event) {
+  if ("composedPath" in event) {
+    return event.composedPath()[0];
+  }
+  return event.target;
+}
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/floating-ui-react/utils/element.js
+function isTargetInsideEnabledTrigger(target, triggerElements) {
+  if (!isElement(target)) {
+    return false;
+  }
+  const targetElement = target;
+  if (triggerElements.hasElement(targetElement)) {
+    return !targetElement.hasAttribute("data-trigger-disabled");
+  }
+  for (const [, trigger] of triggerElements.entries()) {
+    if (contains(trigger, targetElement)) {
+      return !trigger.hasAttribute("data-trigger-disabled");
+    }
+  }
+  return false;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ("composedPath" in event) {
+    return event.composedPath().includes(node);
+  }
+  const eventAgain = event;
+  return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+  return element.matches("html,body");
+}
+function isTypeableElement(element) {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function isInteractiveElement(element) {
+  return element?.closest(`button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`) != null;
+}
+function isTypeableCombobox(element) {
+  if (!element) {
+    return false;
+  }
+  return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+  if (!element || isJSDOM) {
+    return true;
+  }
+  try {
+    return element.matches(":focus-visible");
+  } catch (_e) {
+    return true;
+  }
+}
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement;
+}
+
+export { activeElement, contains, getTarget, isTargetInsideEnabledTrigger, isEventTargetWithin, isRootElement, isTypeableElement, isInteractiveElement, isTypeableCombobox, matchesFocusVisible, getFloatingFocusElement };

package/shadcn/lib/base-ui/_chunk-b40erthe.js

@@ -0,0 +1,7 @@
+// node_modules/.deno/@base-ui+utils@0.2.8/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js
+import * as React from "react";
+"use client";
+var noop = () => {};
+var useIsoLayoutEffect = typeof document !== "undefined" ? React.useLayoutEffect : noop;
+
+export { useIsoLayoutEffect };

package/shadcn/lib/base-ui/_chunk-b5jsqt97.js

@@ -0,0 +1,50 @@
+import {
+  useCompositeListItem
+} from "./_chunk-ek863ta9.js";
+import {
+  useCompositeRootContext
+} from "./_chunk-6xevjepc.js";
+import {
+  useMergedRefs
+} from "./_chunk-1s41sngz.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/composite/item/useCompositeItem.js
+import * as React from "react";
+"use client";
+function useCompositeItem(params = {}) {
+  const {
+    highlightItemOnHover,
+    highlightedIndex,
+    onHighlightedIndexChange
+  } = useCompositeRootContext();
+  const {
+    ref,
+    index
+  } = useCompositeListItem(params);
+  const isHighlighted = highlightedIndex === index;
+  const itemRef = React.useRef(null);
+  const mergedRef = useMergedRefs(ref, itemRef);
+  const compositeProps = React.useMemo(() => ({
+    tabIndex: isHighlighted ? 0 : -1,
+    onFocus() {
+      onHighlightedIndexChange(index);
+    },
+    onMouseMove() {
+      const item = itemRef.current;
+      if (!highlightItemOnHover || !item) {
+        return;
+      }
+      const disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+      if (!isHighlighted && !disabled) {
+        item.focus();
+      }
+    }
+  }), [isHighlighted, onHighlightedIndexChange, index, highlightItemOnHover]);
+  return {
+    compositeProps,
+    compositeRef: mergedRef,
+    index
+  };
+}
+
+export { useCompositeItem };

package/shadcn/lib/base-ui/_chunk-bk7n9s9e.js

@@ -0,0 +1,15 @@
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/checkbox-group/CheckboxGroupContext.js
+import * as React from "react";
+"use client";
+var CheckboxGroupContext = /* @__PURE__ */ React.createContext(undefined);
+if (true)
+  CheckboxGroupContext.displayName = "CheckboxGroupContext";
+function useCheckboxGroupContext(optional = true) {
+  const context = React.useContext(CheckboxGroupContext);
+  if (context === undefined && !optional) {
+    throw new Error("Base UI: CheckboxGroupContext is missing. CheckboxGroup parts must be placed within <CheckboxGroup>.");
+  }
+  return context;
+}
+
+export { useCheckboxGroupContext };

package/shadcn/lib/base-ui/_chunk-c3572b5x.js

@@ -0,0 +1,19 @@
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/fieldset/root/FieldsetRootContext.js
+import * as React from "react";
+"use client";
+var FieldsetRootContext = /* @__PURE__ */ React.createContext({
+  legendId: undefined,
+  setLegendId: () => {},
+  disabled: undefined
+});
+if (true)
+  FieldsetRootContext.displayName = "FieldsetRootContext";
+function useFieldsetRootContext(optional = false) {
+  const context = React.useContext(FieldsetRootContext);
+  if (!context && !optional) {
+    throw new Error("Base UI: FieldsetRootContext is missing. Fieldset parts must be placed within <Fieldset.Root>.");
+  }
+  return context;
+}
+
+export { useFieldsetRootContext };

package/shadcn/lib/base-ui/_chunk-cwr896nf.js

@@ -0,0 +1,25 @@
+import {
+  useStableCallback
+} from "./_chunk-mznt6ktj.js";
+import {
+  useIsoLayoutEffect
+} from "./_chunk-b40erthe.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/useValueChanged.js
+import * as React from "react";
+"use client";
+function useValueChanged(value, onChange) {
+  const valueRef = React.useRef(value);
+  const onChangeCallback = useStableCallback(onChange);
+  useIsoLayoutEffect(() => {
+    if (valueRef.current === value) {
+      return;
+    }
+    onChangeCallback(valueRef.current);
+  }, [value, onChangeCallback]);
+  useIsoLayoutEffect(() => {
+    valueRef.current = value;
+  }, [value]);
+}
+
+export { useValueChanged };

package/shadcn/lib/base-ui/_chunk-drfb9kp2.js

@@ -0,0 +1,27 @@
+import {
+  useIsoLayoutEffect
+} from "./_chunk-b40erthe.js";
+import {
+  useRefWithInit
+} from "./_chunk-1s41sngz.js";
+
+// node_modules/.deno/@base-ui+utils@0.2.8/node_modules/@base-ui/utils/esm/useValueAsRef.js
+"use client";
+function useValueAsRef(value) {
+  const latest = useRefWithInit(createLatestRef, value).current;
+  latest.next = value;
+  useIsoLayoutEffect(latest.effect);
+  return latest;
+}
+function createLatestRef(value) {
+  const latest = {
+    current: value,
+    next: value,
+    effect: () => {
+      latest.current = latest.next;
+    }
+  };
+  return latest;
+}
+
+export { useValueAsRef };

package/shadcn/lib/base-ui/_chunk-ek863ta9.js

@@ -0,0 +1,82 @@
+import {
+  useCompositeListContext
+} from "./_chunk-20rtfsz9.js";
+import {
+  useIsoLayoutEffect
+} from "./_chunk-b40erthe.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/composite/list/useCompositeListItem.js
+import * as React from "react";
+"use client";
+var IndexGuessBehavior = /* @__PURE__ */ function(IndexGuessBehavior2) {
+  IndexGuessBehavior2[IndexGuessBehavior2["None"] = 0] = "None";
+  IndexGuessBehavior2[IndexGuessBehavior2["GuessFromOrder"] = 1] = "GuessFromOrder";
+  return IndexGuessBehavior2;
+}({});
+function useCompositeListItem(params = {}) {
+  const {
+    label,
+    metadata,
+    textRef,
+    indexGuessBehavior,
+    index: externalIndex
+  } = params;
+  const {
+    register,
+    unregister,
+    subscribeMapChange,
+    elementsRef,
+    labelsRef,
+    nextIndexRef
+  } = useCompositeListContext();
+  const indexRef = React.useRef(-1);
+  const [index, setIndex] = React.useState(externalIndex ?? (indexGuessBehavior === IndexGuessBehavior.GuessFromOrder ? () => {
+    if (indexRef.current === -1) {
+      const newIndex = nextIndexRef.current;
+      nextIndexRef.current += 1;
+      indexRef.current = newIndex;
+    }
+    return indexRef.current;
+  } : -1));
+  const componentRef = React.useRef(null);
+  const ref = React.useCallback((node) => {
+    componentRef.current = node;
+    if (index !== -1 && node !== null) {
+      elementsRef.current[index] = node;
+      if (labelsRef) {
+        const isLabelDefined = label !== undefined;
+        labelsRef.current[index] = isLabelDefined ? label : textRef?.current?.textContent ?? node.textContent;
+      }
+    }
+  }, [index, elementsRef, labelsRef, label, textRef]);
+  useIsoLayoutEffect(() => {
+    if (externalIndex != null) {
+      return;
+    }
+    const node = componentRef.current;
+    if (node) {
+      register(node, metadata);
+      return () => {
+        unregister(node);
+      };
+    }
+    return;
+  }, [externalIndex, register, unregister, metadata]);
+  useIsoLayoutEffect(() => {
+    if (externalIndex != null) {
+      return;
+    }
+    return subscribeMapChange((map) => {
+      const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+      if (i != null) {
+        setIndex(i);
+      }
+    });
+  }, [externalIndex, subscribeMapChange, setIndex]);
+  return React.useMemo(() => ({
+    ref,
+    index
+  }), [index, ref]);
+}
+
+export { IndexGuessBehavior, useCompositeListItem };

package/shadcn/lib/base-ui/_chunk-f09cp81f.js

@@ -0,0 +1,12 @@
+// node_modules/.deno/@base-ui+utils@0.2.8/node_modules/@base-ui/utils/esm/useOnFirstRender.js
+import * as React from "react";
+"use client";
+function useOnFirstRender(fn) {
+  const ref = React.useRef(true);
+  if (ref.current) {
+    ref.current = false;
+    fn();
+  }
+}
+
+export { useOnFirstRender };

package/shadcn/lib/base-ui/_chunk-f9tgee1q.js

@@ -0,0 +1,21 @@
+import {
+  FloatingRootStore,
+  PopupTriggerMap
+} from "./_chunk-2tyt8f8r.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/floating-ui-react/utils/getEmptyRootContext.js
+function getEmptyRootContext() {
+  return new FloatingRootStore({
+    open: false,
+    transitionStatus: undefined,
+    floatingElement: null,
+    referenceElement: null,
+    triggerElements: new PopupTriggerMap,
+    floatingId: "",
+    syncOnly: false,
+    nested: false,
+    onOpenChange: undefined
+  });
+}
+
+export { getEmptyRootContext };

package/shadcn/lib/base-ui/_chunk-fch5cba8.js

@@ -0,0 +1,84 @@
+import {
+  useRegisteredLabelId
+} from "./_chunk-w68yxg9d.js";
+import {
+  useLabelableContext
+} from "./_chunk-kfz96xv1.js";
+import {
+  ownerDocument
+} from "./_chunk-xb7ph1ka.js";
+import {
+  getTarget
+} from "./_chunk-atnkefgd.js";
+import {
+  isHTMLElement
+} from "./_chunk-sx6vkz01.js";
+import {
+  useStableCallback
+} from "./_chunk-mznt6ktj.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/labelable-provider/useLabel.js
+"use client";
+function useLabel(params = {}) {
+  const {
+    id: idProp,
+    fallbackControlId,
+    native = false,
+    setLabelId: setLabelIdProp,
+    focusControl: focusControlProp
+  } = params;
+  const {
+    controlId: contextControlId,
+    setLabelId: setContextLabelId
+  } = useLabelableContext();
+  const syncLabelId = useStableCallback((nextLabelId) => {
+    setContextLabelId(nextLabelId);
+    setLabelIdProp?.(nextLabelId);
+  });
+  const id = useRegisteredLabelId(idProp, syncLabelId);
+  const resolvedControlId = contextControlId ?? fallbackControlId;
+  function focusControl(event) {
+    if (focusControlProp) {
+      focusControlProp(event, resolvedControlId);
+      return;
+    }
+    if (!resolvedControlId) {
+      return;
+    }
+    const controlElement = ownerDocument(event.currentTarget).getElementById(resolvedControlId);
+    if (isHTMLElement(controlElement)) {
+      focusElementWithVisible(controlElement);
+    }
+  }
+  function handleInteraction(event) {
+    const target = getTarget(event.nativeEvent);
+    if (target?.closest("button,input,select,textarea")) {
+      return;
+    }
+    if (!event.defaultPrevented && event.detail > 1) {
+      event.preventDefault();
+    }
+    if (native) {
+      return;
+    }
+    focusControl(event);
+  }
+  return native ? {
+    id,
+    htmlFor: resolvedControlId ?? undefined,
+    onMouseDown: handleInteraction
+  } : {
+    id,
+    onClick: handleInteraction,
+    onPointerDown(event) {
+      event.preventDefault();
+    }
+  };
+}
+function focusElementWithVisible(element) {
+  element.focus({
+    focusVisible: true
+  });
+}
+
+export { useLabel, focusElementWithVisible };

package/shadcn/lib/base-ui/_chunk-gfce3j3z.js

@@ -0,0 +1,18 @@
+// node_modules/.deno/@base-ui+utils@0.2.8/node_modules/@base-ui/utils/esm/usePreviousValue.js
+import * as React from "react";
+"use client";
+function usePreviousValue(value) {
+  const [state, setState] = React.useState({
+    current: value,
+    previous: null
+  });
+  if (value !== state.current) {
+    setState({
+      current: value,
+      previous: state.current
+    });
+  }
+  return state.previous;
+}
+
+export { usePreviousValue };