@hanifhan1f/vidstack-react 1.12.26 → 1.12.30

package/prod/chunks/vidstack-CtxjO6HG.js

@@ -0,0 +1,84 @@
+"use client"
+
+import * as React from 'react';
+import { listenEvent, EventsController, animationFrameThrottle, effect } from './vidstack-CYK75vJF.js';
+import { useMediaPlayer } from './vidstack-BCBskRpc.js';
+
+function useClassName(el, className) {
+  React.useEffect(() => {
+    if (!el || !className) return;
+    const tokens = className.split(" ");
+    for (const token of tokens) el.classList.add(token);
+    return () => {
+      for (const token of tokens) el.classList.remove(token);
+    };
+  }, [el, className]);
+}
+function useResizeObserver(el, callback) {
+  React.useEffect(() => {
+    if (!el) return;
+    callback();
+    const observer = new ResizeObserver(animationFrameThrottle(callback));
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [el, callback]);
+}
+function useTransitionActive(el) {
+  const [isActive, setIsActive] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("transitionstart", () => setIsActive(true)).add("transitionend", () => setIsActive(false));
+    return () => events.abort();
+  }, [el]);
+  return isActive;
+}
+function useMouseEnter(el) {
+  const [isMouseEnter, setIsMouseEnter] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("mouseenter", () => setIsMouseEnter(true)).add("mouseleave", () => setIsMouseEnter(false));
+    return () => events.abort();
+  }, [el]);
+  return isMouseEnter;
+}
+function useFocusIn(el) {
+  const [isFocusIn, setIsFocusIn] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("focusin", () => setIsFocusIn(true)).add("focusout", () => setIsFocusIn(false));
+    return () => events.abort();
+  }, [el]);
+  return isFocusIn;
+}
+function useActive(el) {
+  const isMouseEnter = useMouseEnter(el), isFocusIn = useFocusIn(el), prevMouseEnter = React.useRef(false);
+  if (prevMouseEnter.current && !isMouseEnter) return false;
+  prevMouseEnter.current = isMouseEnter;
+  return isMouseEnter || isFocusIn;
+}
+function useColorSchemePreference() {
+  const [colorScheme, setColorScheme] = React.useState("dark");
+  React.useEffect(() => {
+    const media = window.matchMedia("(prefers-color-scheme: light)");
+    function onChange() {
+      setColorScheme(media.matches ? "light" : "dark");
+    }
+    onChange();
+    return listenEvent(media, "change", onChange);
+  }, []);
+  return colorScheme;
+}
+
+function useLayoutName(name) {
+  const player = useMediaPlayer();
+  React.useEffect(() => {
+    if (!player) return;
+    return effect(() => {
+      const el = player.$el;
+      el?.setAttribute("data-layout", name);
+      return () => el?.removeAttribute("data-layout");
+    });
+  }, [player]);
+}
+
+export { useActive, useClassName, useColorSchemePreference, useLayoutName, useResizeObserver, useTransitionActive };

package/prod/chunks/vidstack-D91K36KQ.js

@@ -0,0 +1,206 @@
+"use client"
+
+import * as React from 'react';
+import { composeRefs, useStateContext, useSignal, useSignalRecord } from './vidstack-CYK75vJF.js';
+import { MediaPlayer, MediaAnnouncer, MediaProvider, Controls, ControlsGroup, Tooltip, TooltipTrigger, TooltipContent, ToggleButton, AirPlayButton, GoogleCastButton, PlayButton, CaptionButton, FullscreenButton, MuteButton, PIPButton, SeekButton, LiveButton, Slider, SliderValue, SliderPreview, VolumeSlider, QualitySlider, AudioGainSlider, SpeedSlider, Thumbnail, TimeSlider, SliderChapters, SliderThumbnail, SliderVideo, RadioGroup, Radio, Menu, MenuButton, MenuItems, MenuItem, Gesture, Captions, Poster, Time, MenuPortal, sliderState, mediaState } from 'vidstack';
+
+class MediaPlayerInstance extends MediaPlayer {
+}
+class MediaProviderInstance extends MediaProvider {
+}
+class MediaAnnouncerInstance extends MediaAnnouncer {
+}
+class ControlsInstance extends Controls {
+}
+class ControlsGroupInstance extends ControlsGroup {
+}
+class ToggleButtonInstance extends ToggleButton {
+}
+class CaptionButtonInstance extends CaptionButton {
+}
+class FullscreenButtonInstance extends FullscreenButton {
+}
+class LiveButtonInstance extends LiveButton {
+}
+class MuteButtonInstance extends MuteButton {
+}
+class PIPButtonInstance extends PIPButton {
+}
+class PlayButtonInstance extends PlayButton {
+}
+class AirPlayButtonInstance extends AirPlayButton {
+}
+class GoogleCastButtonInstance extends GoogleCastButton {
+}
+class SeekButtonInstance extends SeekButton {
+}
+class TooltipInstance extends Tooltip {
+}
+class TooltipTriggerInstance extends TooltipTrigger {
+}
+class TooltipContentInstance extends TooltipContent {
+}
+class SliderInstance extends Slider {
+}
+class TimeSliderInstance extends TimeSlider {
+}
+class VolumeSliderInstance extends VolumeSlider {
+}
+class AudioGainSliderInstance extends AudioGainSlider {
+}
+class SpeedSliderInstance extends SpeedSlider {
+}
+class QualitySliderInstance extends QualitySlider {
+}
+class SliderThumbnailInstance extends SliderThumbnail {
+}
+class SliderValueInstance extends SliderValue {
+}
+class SliderVideoInstance extends SliderVideo {
+}
+class SliderPreviewInstance extends SliderPreview {
+}
+class SliderChaptersInstance extends SliderChapters {
+}
+class MenuInstance extends Menu {
+}
+class MenuButtonInstance extends MenuButton {
+}
+class MenuItemsInstance extends MenuItems {
+}
+class MenuItemInstance extends MenuItem {
+}
+class MenuPortalInstance extends MenuPortal {
+}
+class RadioGroupInstance extends RadioGroup {
+}
+class RadioInstance extends Radio {
+}
+class CaptionsInstance extends Captions {
+}
+class GestureInstance extends Gesture {
+}
+class PosterInstance extends Poster {
+}
+class ThumbnailInstance extends Thumbnail {
+}
+class TimeInstance extends Time {
+}
+
+const Slot = React.forwardRef((props, forwardedRef) => {
+  const { children, ...slotProps } = props;
+  const childrenArray = React.Children.toArray(children);
+  const slottable = childrenArray.find(isSlottable);
+  if (slottable) {
+    const newElement = slottable.props.children;
+    const newChildren = childrenArray.map((child) => {
+      if (child === slottable) {
+        if (React.Children.count(newElement) > 1) return React.Children.only(null);
+        return React.isValidElement(newElement) ? newElement.props.children : null;
+      } else {
+        return child;
+      }
+    });
+    return /* @__PURE__ */ React.createElement(SlotClone, { ...slotProps, ref: forwardedRef }, React.isValidElement(newElement) ? React.cloneElement(newElement, void 0, newChildren) : null);
+  }
+  return /* @__PURE__ */ React.createElement(SlotClone, { ...slotProps, ref: forwardedRef }, children);
+});
+Slot.displayName = "Slot";
+const SlotClone = React.forwardRef((props, forwardedRef) => {
+  const { children, ...slotProps } = props;
+  if (React.isValidElement(children)) {
+    return React.cloneElement(children, {
+      ...mergeProps(slotProps, children.props),
+      ref: forwardedRef ? composeRefs(forwardedRef, children.ref) : children.ref
+    });
+  }
+  return React.Children.count(children) > 1 ? React.Children.only(null) : null;
+});
+SlotClone.displayName = "SlotClone";
+const Slottable = ({ children }) => {
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+};
+function isSlottable(child) {
+  return React.isValidElement(child) && child.type === Slottable;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          childPropValue(...args);
+          slotPropValue(...args);
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    }
+  }
+  return { ...slotProps, ...overrideProps };
+}
+
+const NODES = ["button", "div", "span", "img", "video", "audio"];
+const Primitive = NODES.reduce((primitives, node) => {
+  const Node = React.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot : node;
+    return /* @__PURE__ */ React.createElement(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node.displayName = `Primitive.${node}`;
+  return { ...primitives, [node]: Node };
+}, {});
+
+function isRemotionProvider(provider) {
+  return provider?.$$PROVIDER_TYPE === "REMOTION";
+}
+function isRemotionSrc(src) {
+  return src?.type === "video/remotion";
+}
+
+const sliderStateRecord = SliderInstance.state.record, initialSliderStore = Object.keys(sliderStateRecord).reduce(
+  (store, prop) => ({
+    ...store,
+    [prop]() {
+      return sliderStateRecord[prop];
+    }
+  }),
+  {}
+);
+function useSliderState(prop, ref) {
+  const $state = useStateContext(sliderState);
+  return useSignal((ref?.current?.$state || $state || initialSliderStore)[prop]);
+}
+function useSliderStore(ref) {
+  const $state = useStateContext(sliderState);
+  return useSignalRecord(ref?.current ? ref.current.$state : $state || initialSliderStore);
+}
+
+const IS_SERVER = typeof document === "undefined";
+
+const mediaStateRecord = MediaPlayerInstance.state.record, initialMediaStore = Object.keys(mediaStateRecord).reduce(
+  (store, prop) => ({
+    ...store,
+    [prop]() {
+      return mediaStateRecord[prop];
+    }
+  }),
+  {}
+);
+function useMediaState(prop, ref) {
+  const $state = useStateContext(mediaState);
+  return useSignal((ref?.current?.$state || $state || initialMediaStore)[prop]);
+}
+function useMediaStore(ref) {
+  const $state = useStateContext(mediaState);
+  return useSignalRecord(ref?.current ? ref.current.$state : $state || initialMediaStore);
+}
+
+export { AirPlayButtonInstance, AudioGainSliderInstance, CaptionButtonInstance, CaptionsInstance, ControlsGroupInstance, ControlsInstance, FullscreenButtonInstance, GestureInstance, GoogleCastButtonInstance, IS_SERVER, LiveButtonInstance, MediaAnnouncerInstance, MediaPlayerInstance, MediaProviderInstance, MenuButtonInstance, MenuInstance, MenuItemInstance, MenuItemsInstance, MenuPortalInstance, MuteButtonInstance, PIPButtonInstance, PlayButtonInstance, PosterInstance, Primitive, QualitySliderInstance, RadioGroupInstance, RadioInstance, SeekButtonInstance, SliderChaptersInstance, SliderInstance, SliderPreviewInstance, SliderThumbnailInstance, SliderValueInstance, SliderVideoInstance, SpeedSliderInstance, ThumbnailInstance, TimeInstance, TimeSliderInstance, ToggleButtonInstance, TooltipContentInstance, TooltipInstance, TooltipTriggerInstance, VolumeSliderInstance, isRemotionProvider, isRemotionSrc, useMediaState, useMediaStore, useSliderState, useSliderStore };

package/prod/chunks/vidstack-DJThTSEm.js

@@ -0,0 +1,125 @@
+"use client"
+
+import * as React from 'react';
+import { MediaRemoteControl, sortVideoQualities, DEFAULT_PLAYBACK_RATES } from 'vidstack';
+import { MediaPlayerInstance } from './vidstack-D91K36KQ.js';
+import { useMediaContext } from './vidstack-BCBskRpc.js';
+import { useSignal, isString } from './vidstack-CYK75vJF.js';
+
+function useMediaRemote(target) {
+  const media = useMediaContext(), remote = React.useRef(null);
+  if (!remote.current) {
+    remote.current = new MediaRemoteControl();
+  }
+  React.useEffect(() => {
+    const ref = target && "current" in target ? target.current : target, isPlayerRef = ref instanceof MediaPlayerInstance, player = isPlayerRef ? ref : media?.player;
+    remote.current.setPlayer(player ?? null);
+    remote.current.setTarget(ref ?? null);
+  }, [media, target && "current" in target ? target.current : target]);
+  return remote.current;
+}
+
+function useVideoQualityOptions({
+  auto = true,
+  sort = "descending"
+} = {}) {
+  const media = useMediaContext(), { qualities, quality, autoQuality, canSetQuality } = media.$state, $qualities = useSignal(qualities);
+  useSignal(quality);
+  useSignal(autoQuality);
+  useSignal(canSetQuality);
+  return React.useMemo(() => {
+    const sortedQualities = sortVideoQualities($qualities, sort === "descending"), options = sortedQualities.map((q) => {
+      return {
+        quality: q,
+        label: q.height + "p",
+        value: getQualityValue(q),
+        bitrateText: q.bitrate && q.bitrate > 0 ? `${(q.bitrate / 1e6).toFixed(2)} Mbps` : null,
+        get selected() {
+          return q === quality();
+        },
+        get autoSelected() {
+          return autoQuality();
+        },
+        select(trigger) {
+          const index = qualities().indexOf(q);
+          if (index >= 0) media.remote.changeQuality(index, trigger);
+        }
+      };
+    });
+    if (auto) {
+      options.unshift({
+        quality: null,
+        label: isString(auto) ? auto : "Auto",
+        value: "auto",
+        bitrateText: null,
+        get selected() {
+          return autoQuality();
+        },
+        get autoSelected() {
+          return autoQuality();
+        },
+        select(trigger) {
+          media.remote.requestAutoQuality(trigger);
+        }
+      });
+    }
+    Object.defineProperty(options, "disabled", {
+      get() {
+        return !canSetQuality() || $qualities.length <= 1;
+      }
+    });
+    Object.defineProperty(options, "selectedQuality", {
+      get() {
+        return quality();
+      }
+    });
+    Object.defineProperty(options, "selectedValue", {
+      get() {
+        const $quality = quality();
+        return !autoQuality() && $quality ? getQualityValue($quality) : "auto";
+      }
+    });
+    return options;
+  }, [$qualities, sort]);
+}
+function getQualityValue(quality) {
+  return quality.height + "_" + quality.bitrate;
+}
+
+function usePlaybackRateOptions({
+  rates = DEFAULT_PLAYBACK_RATES,
+  normalLabel = "Normal"
+} = {}) {
+  const media = useMediaContext(), { playbackRate, canSetPlaybackRate } = media.$state;
+  useSignal(playbackRate);
+  useSignal(canSetPlaybackRate);
+  return React.useMemo(() => {
+    const options = rates.map((opt) => {
+      const label = typeof opt === "number" ? opt === 1 && normalLabel ? normalLabel : opt + "x" : opt.label, rate = typeof opt === "number" ? opt : opt.rate;
+      return {
+        label,
+        value: rate.toString(),
+        rate,
+        get selected() {
+          return playbackRate() === rate;
+        },
+        select(trigger) {
+          media.remote.changePlaybackRate(rate, trigger);
+        }
+      };
+    });
+    Object.defineProperty(options, "disabled", {
+      get() {
+        return !canSetPlaybackRate() || !options.length;
+      }
+    });
+    Object.defineProperty(options, "selectedValue", {
+      get() {
+        return playbackRate().toString();
+      }
+    });
+    return options;
+  }, [rates]);
+}
+
+export { useMediaRemote, usePlaybackRateOptions, useVideoQualityOptions };