@scrippsproduct/networks-ui-library 1.0.15

package/dist/components/Carousel/Carousel.js

@@ -0,0 +1,298 @@
+import { jsx as n, Fragment as F, jsxs as D } from "react/jsx-runtime";
+import { useRef as c, useState as P, useEffect as O, useCallback as u } from "react";
+import W from "./CarouselUtils.class.js";
+import { CarouselSlide as J } from "../CarouselSlide/CarouselSlide.js";
+import { chunkArray as Q, classes as y } from "../../utils/helpers.js";
+import { C as X } from "../../chevron-left-DmvQntvu.mjs";
+import { C as Y } from "../../chevron-right-CaAz6ISN.mjs";
+import '../../assets/Pagination.css';const Z = "_carousel_1booq_1", ee = "_carousel__scroller_1booq_11", a = {
+  carousel: Z,
+  carousel__scroller: ee,
+  "carousel-controls": "_carousel-controls_1booq_38",
+  "carousel-controls__btn": "_carousel-controls__btn_1booq_42",
+  "carousel-controls__previous": "_carousel-controls__previous_1booq_67",
+  "carousel-controls__next": "_carousel-controls__next_1booq_74",
+  "carousel-nav": "_carousel-nav_1booq_86",
+  "carousel-nav__list": "_carousel-nav__list_1booq_90",
+  "carousel-nav__item": "_carousel-nav__item_1booq_99"
+}, re = window.matchMedia("(max-width: 600px)"), te = window.matchMedia("(max-width: 800px"), le = window.matchMedia("(max-width: 1024px"), oe = window.matchMedia("(max-width: 1280px");
+function fe({
+  id: A,
+  slides: z,
+  options: x = {
+    paginationType: "dots",
+    showControls: !0,
+    controlArrowSize: 48,
+    controlButtonsOffset: 12,
+    showScrollbar: !1,
+    startIndex: 0,
+    variableHeight: !1,
+    title: "",
+    autoplay: !1,
+    autoplayDelay: 3500,
+    showPagination: !1,
+    gutterSize: 25,
+    slideAspectRatio: "4/2",
+    slideGap: 1.5,
+    cellsPerSlide: 1,
+    cellAspectRatio: "4/2",
+    cellsPosition: "center",
+    wrapAround: !0
+  }
+}) {
+  const _ = c(`carousel-${A}`), R = c(null), i = c(null), I = c(null), m = c(z), E = c(null), S = c(null), l = c(null), e = c(x), $ = c(x.showPagination), T = c("-50%"), [N, V] = P([]), [t, d] = P(null), [k, j] = P([]);
+  O(() => {
+    ((o = null) => {
+      re.matches ? (d({
+        ...e.current,
+        showControls: !1,
+        showPagination: !1,
+        cellsPerSlide: 1,
+        cellsPosition: e.current.wrapAround ? "center" : "flex-start",
+        gutterSize: 10
+      }), e.current = {
+        ...e.current,
+        showControls: !1,
+        showPagination: !1,
+        cellsPerSlide: 1,
+        cellsPosition: e.current.wrapAround ? "center" : "flex-start",
+        gutterSize: 10
+      }, $.current = !1) : te.matches ? e.current.cellsPerSlide > 2 ? (d({
+        ...e.current,
+        cellsPerSlide: 2,
+        showControls: !1,
+        gutterSize: 10
+      }), e.current = {
+        ...e.current,
+        cellsPerSlide: 2,
+        showControls: !1,
+        gutterSize: 10
+      }) : (d({
+        ...e.current,
+        showControls: !1,
+        gutterSize: 10
+      }), e.current = {
+        ...e.current,
+        showControls: !1,
+        gutterSize: 10
+      }) : le.matches ? e.current.cellsPerSlide > 3 ? (d({
+        ...e.current,
+        cellsPerSlide: 3,
+        showControls: !1,
+        gutterSize: 10
+      }), e.current = {
+        ...e.current,
+        cellsPerSlide: 3,
+        showControls: !1,
+        gutterSize: 10
+      }) : (d({
+        ...e.current,
+        showControls: !1,
+        gutterSize: 10
+      }), e.current = {
+        ...e.current,
+        showControls: !1,
+        gutterSize: 10
+      }) : oe.matches && e.current.showPagination ? (d({
+        ...e.current,
+        showControls: !1
+      }), e.current = {
+        ...e.current,
+        showControls: !1
+      }) : d({
+        ...e.current
+      });
+    })();
+  }, []);
+  const L = u((r, o) => {
+    const f = Q(o, r);
+    j([...f]);
+    let h = [];
+    for (let s = 0; s <= f.length - 1; s++) {
+      h[s] = {}, h[s].ariaLabel = `${s + 1} of ${f.length}`, h[s].layout = f[s][0].layout, h[s].cells = [];
+      for (let w = 0; w <= f[s].length - 1; w++)
+        h[s].cells[w] = {
+          props: f[s][w].props
+        };
+    }
+    const C = [...h], b = [...h], U = C.slice(-1), K = C.slice(0);
+    return b.push(K[0]), b.unshift(U[0]), e.current.wrapAround && r.length > o ? b : C;
+  }, []), p = u(() => {
+    e.current.autoplay && l.current.clearTimer();
+  }, []), B = u((r) => {
+    p();
+    const o = r.key;
+    o === "ArrowLeft" ? (r.preventDefault(), l.current.determineScrollAction(-1)) : o === "ArrowRight" && (r.preventDefault(), l.current.determineScrollAction(1));
+  }, [p]), G = u((r) => {
+    p(), i.current.addEventListener("scrollend", () => {
+      l.current.handleScrollEnd();
+    }, { once: !0 });
+  }, [p]), g = u((r) => {
+    p(), i.current.addEventListener("scrollend", () => {
+      l.current.handleScrollEnd(), i.current.addEventListener("scroll", g, { once: !0 });
+    }, { once: !0 });
+  }, [p]), H = () => {
+    l.current && e.current.autoplay && l.current.clearTimer();
+  }, v = u(() => {
+    //! make sure class is only instantiated once because of reacts
+    //! "strict" mode double do hocus pocus
+    l.current === null && (l.current = new W({
+      carouselEl: R.current,
+      scrollerEl: i.current,
+      paginationEl: I.current,
+      slides: m.current,
+      navBtnEls: {
+        next: E.current,
+        previous: S.current
+      },
+      id: _.current,
+      options: {
+        autoplay: e.current.autoplay,
+        wrapAround: e.current.wrapAround && m.current.length > e.current.cellsPerSlide,
+        showPagination: e.current.showPagination,
+        delay: e.current.autoplayDelay,
+        slideGutterSize: e.current.gutterSize,
+        slideAspectRatio: e.current.slideAspectRatio,
+        showControls: e.current.showControls && m.current.length > e.current.cellsPerSlide,
+        cellsPerSlide: e.current.cellsPerSlide
+      }
+    }));
+  }, []), M = u(() => {
+    i.current.addEventListener("scroll", g, { once: !0 });
+  }, [g]), q = u(() => {
+    if (V(L(m.current, e.current.cellsPerSlide)), m.current.length > e.current.cellsPerSlide) {
+      let r = setInterval(() => {
+        i.current !== null && (S.current !== null && e.current.showControls || !e.current.showControls) && (clearInterval(r), M(), v());
+      }, 100);
+    } else {
+      let r = setInterval(() => {
+        i.current !== null && (clearInterval(r), v());
+      }, 100);
+    }
+  }, [L, M, v]);
+  return O(() => {
+    if (t !== null) {
+      if (t.showControls) {
+        let r = 0;
+        t.showPagination && (r = r + 25), t.showScrollbar && (r = r + 6), T.current = `calc(-50% - ${r}px)`;
+      }
+      q();
+    }
+    return () => {
+      H();
+    };
+  }, [q, t]), /* @__PURE__ */ n(F, { children: t !== null && /* @__PURE__ */ D(
+    "div",
+    {
+      className: a.carousel,
+      id: _.current,
+      ref: R,
+      tabIndex: -1,
+      role: "region",
+      "aria-roledescription": "carousel",
+      "aria-label": t.title,
+      onKeyDown: B,
+      style: {
+        "--_carousel-gutters": t.wrapAround ? `${t.gutterSize <= 25 ? t.gutterSize : 25}%` : `0 ${t.gutterSize <= 25 ? t.gutterSize : 25}%`,
+        "--_slide-aspect-ratio": t.slideAspectRatio,
+        "--_cell-aspect-ratio": t.cellAspectRatio,
+        "--_slide-cell-size": `${100 / t.cellsPerSlide}%`,
+        "--_cells-position": t.cellsPosition,
+        "--_control-btns-offset-x": `${t.controlButtonsOffset}rem`,
+        "--_slide-gap": `${t.slideGap}rem`,
+        "--_controls-transform": T.current
+      },
+      children: [
+        /* @__PURE__ */ n(
+          "ol",
+          {
+            className: a.carousel__scroller,
+            ref: i,
+            role: "group",
+            "aria-label": "Items Scroller",
+            "aria-live": "Polite",
+            tabIndex: 0,
+            onMouseEnter: (r) => {
+              e.current.autoplay && l.current !== null && l.current.clearTimer();
+            },
+            onMouseLeave: (r) => {
+              e.current.autoplay && l.current !== null && l.current.startTimer();
+            },
+            onTouchStart: G,
+            "data-scrollbar": t.showScrollbar,
+            children: N.length > 0 && N.map((r, o) => /* @__PURE__ */ n(
+              J,
+              {
+                slide: r,
+                index: o,
+                currentIndex: t.wrapAround ? 1 : 0,
+                variableHeight: t.variableHeight
+              },
+              `carousel${A}-slide${o}`
+            ))
+          }
+        ),
+        t.showControls && z.length > e.current.cellsPerSlide && /* @__PURE__ */ D("div", { className: a["carousel-controls"], children: [
+          /* @__PURE__ */ n(
+            "button",
+            {
+              type: "button",
+              ref: S,
+              title: "Previous Item",
+              className: y([a["carousel-controls__btn"], a["carousel-controls__previous"], "carousel-controls__previous"]),
+              "aria-controls": _.current,
+              "aria-label": "Previous Item",
+              onClick: (r) => {
+                l.current.determineScrollAction(-1);
+              },
+              onMouseEnter: (r) => {
+                e.current.autoplay && l.current !== null && l.current.clearTimer();
+              },
+              onMouseLeave: (r) => {
+                e.current.autoplay && l.current !== null && l.current.startTimer();
+              },
+              children: /* @__PURE__ */ n("i", { "aria-hidden": "true", children: /* @__PURE__ */ n(X, { width: t.controlArrowSize, height: t.controlArrowSize }) })
+            }
+          ),
+          /* @__PURE__ */ n(
+            "button",
+            {
+              type: "button",
+              ref: E,
+              title: "Next Item",
+              className: y([a["carousel-controls__btn"], a["carousel-controls__next"], "carousel-controls__next"]),
+              "aria-controls": _.current,
+              "aria-label": "Next Item",
+              onClick: (r) => {
+                l.current.determineScrollAction(1);
+              },
+              onMouseEnter: (r) => {
+                e.current.autoplay && l.current !== null && l.current.clearTimer();
+              },
+              onMouseLeave: (r) => {
+                e.current.autoplay && l.current !== null && l.current.startTimer();
+              },
+              children: /* @__PURE__ */ n("i", { "aria-hidden": "true", children: /* @__PURE__ */ n(Y, { width: t.controlArrowSize, height: t.controlArrowSize }) })
+            }
+          )
+        ] }),
+        $.current && k.length > 1 && /* @__PURE__ */ n("div", { className: [a["carousel-nav"], "carousel-nav"].join(" "), children: /* @__PURE__ */ n("ol", { className: a["carousel-nav__list"], ref: I, children: k.map((r, o) => /* @__PURE__ */ n(
+          "li",
+          {
+            className: y([a["carousel-nav__item"], "carousel-nav__item"]),
+            "data-current": o === 0 ? "true" : "false",
+            onClick: (f) => {
+              l.current.navigateToIndex(o);
+            },
+            title: `Navigate to slide ${o + 1}`
+          },
+          `carousel${_}-nav-${o}`
+        )) }) })
+      ]
+    }
+  ) });
+}
+export {
+  fe as Carousel,
+  fe as default
+};

package/dist/components/Carousel/CarouselUtils.class.d.ts

@@ -0,0 +1,68 @@
+export default class CarouselUtils {
+    constructor({ carouselEl, scrollerEl, paginationEl, slides, navBtnEls, options }: {
+        carouselEl: any;
+        scrollerEl: any;
+        paginationEl: any;
+        slides: any;
+        navBtnEls?: {
+            next: {};
+            previous: {};
+        } | undefined;
+        options: any;
+    });
+    carouselEl: any;
+    scrollerEl: any;
+    paginationEl: any;
+    slides: any;
+    currentIndex: number;
+    slideEls: any[];
+    navBtnEls: {
+        next: {};
+        previous: {};
+    };
+    currentIntersecting: {};
+    options: any;
+    timer: NodeJS.Timeout | null;
+    timerInterval: any;
+    slideGutterSize: any;
+    showPagination: any;
+    isInitialScroll: boolean;
+    totalSlideEls: number;
+    totalSlides: number;
+    carouselObserver: IntersectionObserver | undefined;
+    /**
+     * starts the autoplay timer
+     */
+    startTimer(): void;
+    /**
+     * clears the autoplay timer
+     */
+    clearTimer(): void;
+    /**
+     * checks to see if the scroller is moving to the
+     * end or beginning, if so it makes the appropriate
+     * updates
+     *
+     * @param {number} dir - a number representing the direction of scroll 1 for forward, -1 for backward
+     */
+    determineScrollAction(dir: number): void;
+    /**
+     * Navigates the carousel to a specific index
+     *
+     * @param {number} index
+     * @returns void
+     */
+    navigateToIndex(index: number): void;
+    /**
+     * Returns the current index of the carousel
+     *
+     * @returns {number} - the current index of the carousel
+     */
+    getCurrentIndex(): number;
+    /**
+     * Handles the scrollend event - determines which slide is in view and updates the carousel
+     * @returns void
+     */
+    handleScrollEnd(): void;
+    #private;
+}

package/dist/components/Carousel/CarouselUtils.class.js

@@ -0,0 +1,187 @@
+var w = (o) => {
+  throw TypeError(o);
+};
+var G = (o, t, s) => t.has(o) || w("Cannot " + s);
+var y = (o, t, s) => t.has(o) ? w("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(o) : t.set(o, s);
+var i = (o, t, s) => (G(o, t, "access private method"), s);
+var e, T, S, L, p, f, v, B, A, z;
+class N {
+  constructor({ carouselEl: t, scrollerEl: s, paginationEl: a, slides: O, navBtnEls: P = { next: {}, previous: {} }, options: n }) {
+    y(this, e);
+    if (!("onscrollend" in window)) {
+      let d = function(h, r, b) {
+        let c = h[r];
+        h[r] = function() {
+          let l = Array.prototype.slice.apply(arguments, [0]);
+          c.apply(this, l), l.unshift(c), b.apply(this, l);
+        };
+      }, I = function(h, r, b, c) {
+        if (r !== "scroll" && r !== "scrollend")
+          return;
+        let l = this, u = E.get(l);
+        if (u === void 0) {
+          let x = 0;
+          u = {
+            scrollListener: (W) => {
+              clearTimeout(x), x = setTimeout(() => {
+                m.size ? setTimeout(u.scrollListener, 100) : (l.dispatchEvent(C), x = 0);
+              }, 100);
+            },
+            listeners: 0
+            // Count of number of listeners.
+          }, h.apply(l, ["scroll", u.scrollListener]), E.set(l, u);
+        }
+        u.listeners++;
+      }, g = function(h, r, b) {
+        if (r !== "scroll" && r !== "scrollend")
+          return;
+        let c = this, l = E.get(c);
+        l !== void 0 && (l[r]--, !(--l.listeners > 0) && (h.apply(c, ["scroll", l.scrollListener]), E.delete(c)));
+      };
+      const C = new Event("scrollend"), m = /* @__PURE__ */ new Set();
+      document.addEventListener("touchstart", (h) => {
+        for (let r of h.changedTouches)
+          m.add(r.identifier);
+      }, { passive: !0 }), document.addEventListener("touchend", (h) => {
+        for (let r of h.changedTouches)
+          m.delete(r.identifier);
+      }, { passive: !0 });
+      let E = /* @__PURE__ */ new WeakMap();
+      d(Element.prototype, "addEventListener", I), d(window, "addEventListener", I), d(document, "addEventListener", I), d(Element.prototype, "removeEventListener", g), d(window, "removeEventListener", g), d(document, "removeEventListener", g);
+    }
+    this.carouselEl = t, this.scrollerEl = s, this.paginationEl = a, this.slides = O, this.currentIndex = 0, this.slideEls = [...s.children], this.navBtnEls = P, this.currentIntersecting = {}, this.options = n, n.autoplay && (this.timer = null, this.timerInterval = (n == null ? void 0 : n.delay) ?? 3500, this.startTimer()), this.slideGutterSize = (n == null ? void 0 : n.slideGutterSize) ?? 25, this.showPagination = n == null ? void 0 : n.showPagination, this.isInitialScroll = !0, this.totalSlideEls = this.slideEls.length, this.totalSlides = Math.ceil(this.slides.length / this.options.cellsPerSlide), i(this, e, T).call(this), i(this, e, L).call(this), i(this, e, S).call(this);
+  }
+  /**
+   * starts the autoplay timer
+   */
+  startTimer() {
+    this.timer || (this.timer = setInterval(() => {
+      this.determineScrollAction(1);
+    }, this.timerInterval));
+  }
+  /**
+   * clears the autoplay timer
+   */
+  clearTimer() {
+    clearInterval(this.timer), this.timer = null;
+  }
+  /**
+   * checks to see if the scroller is moving to the
+   * end or beginning, if so it makes the appropriate 
+   * updates
+   * 
+   * @param {number} dir - a number representing the direction of scroll 1 for forward, -1 for backward
+   */
+  determineScrollAction(t) {
+    this.options.autoplay && this.timer !== null && this.clearTimer(), t === 1 ? this.currentIndex === this.totalSlides - 1 ? this.options.wrapAround && (this.scrollerEl.style.scrollBehavior = "auto", this.scrollerEl.scrollTo(0, 0), i(this, e, f).call(this, t), this.currentIndex = 0) : (i(this, e, f).call(this, t), this.currentIndex += 1) : t === -1 && (this.currentIndex === 0 ? this.options.wrapAround && (this.scrollerEl.style.scrollBehavior = "auto", this.scrollerEl.scrollTo(99999, 0), this.currentIndex = this.totalSlides - 1, i(this, e, f).call(this, t)) : (i(this, e, f).call(this, t), this.currentIndex -= 1)), this.options.autoplay && this.timer === null && this.startTimer();
+  }
+  /**
+   * Navigates the carousel to a specific index
+   * 
+   * @param {number} index 
+   * @returns void
+   */
+  navigateToIndex(t) {
+    if (t === this.currentIndex) return;
+    this.options.autoplay && this.clearTimer();
+    let s = t > this.currentIndex ? t - this.currentIndex : this.currentIndex - t, a = t > this.currentIndex ? 1 : -1;
+    this.currentIndex = t, i(this, e, f).call(this, a, s), this.options.autoplay && this.startTimer(), i(this, e, v).call(this);
+  }
+  /**
+   * Returns the current index of the carousel
+   * 
+   * @returns {number} - the current index of the carousel
+   */
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  /**
+   * Handles the scrollend event - determines which slide is in view and updates the carousel
+   * @returns void
+   */
+  handleScrollEnd() {
+    if (this.timer === null && this.options.autoplay && this.startTimer(), this.currentIntersecting.target) {
+      const t = Number.parseInt(this.currentIntersecting.target.getAttribute("data-index"), 10);
+      if (!this.options.wrapAround) {
+        this.currentIndex = t, i(this, e, v).call(this);
+        return;
+      }
+      t === 0 ? (this.currentIndex = this.slides.length - 1, i(this, e, p).call(this, { scrollport: this.scrollerEl, element: this.slideEls[this.totalSlides] })) : t === this.totalSlideEls - 1 ? (this.currentIndex = 0, i(this, e, p).call(this, { scrollport: this.scrollerEl, element: this.slideEls[1] })) : this.currentIndex = t - 1;
+    }
+    i(this, e, v).call(this);
+  }
+}
+e = new WeakSet(), /**
+ * adds an observer to the scroller element that we can use to 
+ * determine which slide is intersecting
+ */
+T = function() {
+  this.carouselObserver = new IntersectionObserver((t) => {
+    for (let s of t)
+      s.isIntersecting && (this.currentIntersecting = s);
+  }, {
+    root: this.scrollerEl,
+    threshold: 0.8
+  });
+}, /**
+ * sets listeners on the slide elements for the observer
+ */
+S = function() {
+  for (let t of this.slideEls)
+    this.carouselObserver.observe(t);
+}, /**
+ * sets some intial settings for the carousel based on some of the options
+ */
+L = function() {
+  this.options.wrapAround ? (this.scrollerEl.style.scrollBehavior = "auto", this.scrollerEl.scrollTo(-9999, 0), i(this, e, p).call(this, { scrollport: this.scrollerEl, element: this.scrollerEl.children[1] })) : this.options.showControls ? (this.navBtnEls.previous.setAttribute("disabled", !0), i(this, e, v).call(this)) : i(this, e, A).call(this), this.totalSlides === 1 && this.slideEls[0].removeAttribute("inert");
+}, /**
+ * Scrolls the carousel to a specific child element
+ * @param {*} param0 - an object containing the scrollport element and the child element to scroll to 
+ */
+p = function({ scrollport: t, element: s }) {
+  const a = this.slideGutterSize * 2 / 100;
+  t.style.scrollBehavior = "auto", t.scrollTo(Math.abs(t.offsetLeft - s.offsetLeft + s.clientWidth * a), 0);
+}, /**
+ * Scrolls the carousel in a specified direction by a specified distance
+ * 
+ * @param {number} dir - a number representing the direction of scroll 1 for forward, -1 for backward 
+ * @param {number} distance - a number representing the number of slides to scroll
+ */
+f = function(t, s = 1) {
+  this.scrollerEl.style.scrollBehavior = "smooth", this.scrollerEl.scrollBy({
+    left: this.scrollerEl.clientWidth * ((100 - this.slideGutterSize * 2) / 100) * s * t,
+    top: 0,
+    behavior: "smooth"
+  });
+}, /**
+ * Syncronizes various elements of the carousel
+ * 
+ * add methods here to have them sync 
+ * when scroller is scrolled
+ */
+v = function() {
+  i(this, e, A).call(this), this.showPagination && i(this, e, z).call(this), this.options.wrapAround || i(this, e, B).call(this);
+}, /**
+ * Sets the control arrow buttons to disabled if the carousel is at the start or end
+ */
+B = function() {
+  this.navBtnEls.previous && this.navBtnEls.next && (this.navBtnEls.previous.removeAttribute("disabled"), this.navBtnEls.next.removeAttribute("disabled"), this.currentIndex === 0 && this.navBtnEls.previous.toggleAttribute("disabled"), this.currentIndex === this.slideEls.length - 1 && this.navBtnEls.next.toggleAttribute("disabled"));
+}, /**
+ * Sets the inert attribute on all slides that are not the current slide
+ */
+A = function() {
+  const t = this.options.wrapAround ? this.currentIndex + 1 : this.currentIndex;
+  this.slideEls.length === 1 ? this.slideEls[0].removeAttribute("inert") : this.slideEls.forEach((s, a) => {
+    s.toggleAttribute("inert", a !== t);
+  });
+}, /**
+ * Sets the pagination indicator to the current slide
+ */
+z = function() {
+  [...this.paginationEl.children].forEach((t, s) => {
+    s === this.currentIndex ? t.setAttribute("data-current", "true") : t.setAttribute("data-current", "false");
+  });
+};
+export {
+  N as default
+};

package/dist/components/Carousel/index.d.ts

@@ -0,0 +1 @@
+export { Carousel, Carousel as default } from './Carousel';

package/dist/components/Carousel/index.js

@@ -0,0 +1,5 @@
+import { Carousel as o, Carousel as r } from "./Carousel.js";
+export {
+  o as Carousel,
+  r as default
+};

package/dist/components/Carousel/navigations/Pagination.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export default Pagination;
+declare const Pagination: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

package/dist/components/Carousel/navigations/Pagination.js

@@ -0,0 +1,18 @@
+import { jsx as e } from "react/jsx-runtime";
+import t from "react";
+import '../../../assets/Pagination.css';const l = {
+  "carousel-nav": "_carousel-nav_1booq_86",
+  "carousel-nav__list": "_carousel-nav__list_1booq_90",
+  "carousel-nav__item": "_carousel-nav__item_1booq_99"
+}, v = t.forwardRef(({ slides: o, carouselId: r, CarouselUtil: _, scrollerRef: c }, s) => /* @__PURE__ */ e("div", { className: `${l["carousel-nav"]} carousel-nav`, children: /* @__PURE__ */ e("ol", { className: l["carousel-nav__list"], ref: s, children: o.map((u, a) => /* @__PURE__ */ e(
+  "li",
+  {
+    className: `${l["carousel-nav__item"]} carousel-nav__item`,
+    "data-current": a === 0 ? "true" : "false",
+    title: `Navigate to slide ${a + 1}`
+  },
+  `carousel${r}-nav-${a}`
+)) }) }));
+export {
+  v as default
+};

package/dist/components/CarouselSlide/CarouselSlide.d.ts

@@ -0,0 +1,7 @@
+export function CarouselSlide({ slide, index, currentIndex, variableHeight }: {
+    slide: any;
+    index: any;
+    currentIndex: any;
+    variableHeight?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export default CarouselSlide;

package/dist/components/CarouselSlide/CarouselSlide.js

@@ -0,0 +1,37 @@
+import { jsx as t, Fragment as c } from "react/jsx-runtime";
+import { useState as d, useEffect as m, createElement as p } from "react";
+import { classes as f } from "../../utils/helpers.js";
+import { slideLayoutsMap as h } from "../../settings.js";
+import '../../assets/CarouselSlide.css';const g = "_slide_gx8qn_1", i = {
+  slide: g,
+  "slide--variable-height": "_slide--variable-height_gx8qn_17"
+};
+function v({
+  slide: e,
+  index: l,
+  currentIndex: r,
+  variableHeight: s = !1
+}) {
+  const [a, o] = d(null);
+  return m(() => {
+    o(h.get(e.layout));
+  }, [e]), /* @__PURE__ */ t(c, { children: /* @__PURE__ */ t(
+    "li",
+    {
+      className: f([
+        i.slide,
+        "slide",
+        s ? i["slide--variable-height"] : ""
+      ]),
+      "aria-label": e.ariaLabel,
+      "aria-roledescription": "carousel-item",
+      inert: r !== l ? "" : null,
+      "data-index": l,
+      children: a !== null && e.cells.map((n, u) => /* @__PURE__ */ p(a, { ...n.props, key: `slide${l}-cell${u}` }))
+    }
+  ) });
+}
+export {
+  v as CarouselSlide,
+  v as default
+};

package/dist/components/CarouselSlide/index.d.ts

@@ -0,0 +1 @@
+export { CarouselSlide, CarouselSlide as default } from './CarouselSlide';

package/dist/components/CarouselSlide/index.js

@@ -0,0 +1,5 @@
+import { CarouselSlide as a, CarouselSlide as o } from "./CarouselSlide.js";
+export {
+  a as CarouselSlide,
+  o as default
+};

package/dist/components/CarouselSlide/slide-layouts/Empty/Empty.d.ts

@@ -0,0 +1,2 @@
+export function Empty(): import("react/jsx-runtime").JSX.Element;
+export default Empty;

package/dist/components/CarouselSlide/slide-layouts/Empty/Empty.js

@@ -0,0 +1,9 @@
+import { jsx as t } from "react/jsx-runtime";
+import "react";
+function r() {
+  return /* @__PURE__ */ t("div", { className: "empty-slide" });
+}
+export {
+  r as Empty,
+  r as default
+};

package/dist/components/CarouselSlide/slide-layouts/Empty/index.d.ts

@@ -0,0 +1 @@
+export { Empty, Empty as default } from './Empty';

package/dist/components/CarouselSlide/slide-layouts/Empty/index.js

@@ -0,0 +1,5 @@
+import { Empty as p, Empty as a } from "./Empty.js";
+export {
+  p as Empty,
+  a as default
+};

package/dist/components/CarouselSlide/slide-layouts/Figure/Figure.d.ts

@@ -0,0 +1,9 @@
+export function FigureSlide({ images, imagesPerSlide }: {
+    images?: {
+        url: string;
+        altText: string;
+        caption: string;
+    }[] | undefined;
+    imagesPerSlide?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export default FigureSlide;