@kiva/kv-components 3.106.0 → 3.107.1

package/dist/utils/chunk-AZPWOFD5.js

@@ -0,0 +1,148 @@
+import {
+  throttle
+} from "./chunk-HV3AUBFT.js";
+
+// utils/carousels.js
+import {
+  computed,
+  onMounted,
+  onUnmounted,
+  ref,
+  toRefs,
+  nextTick
+} from "vue-demi";
+import EmblaCarousel from "embla-carousel";
+function carouselUtil(props, { emit, slots }, extraEmblaOptions) {
+  var _a;
+  const {
+    emblaOptions,
+    slidesToScroll
+  } = toRefs(props);
+  const rootEl = ref(null);
+  const embla = ref(null);
+  const slides = ref([]);
+  const startIndex = ((_a = emblaOptions.value) == null ? void 0 : _a.startIndex) ?? 0;
+  const currentIndex = ref(startIndex);
+  const slideIndicatorCount = ref(0);
+  const componentSlotKeys = computed(() => {
+    const keys = Object.keys(slots);
+    return keys;
+  });
+  const nextIndex = computed(() => {
+    const nextSlideIndex = currentIndex.value + 1;
+    if (nextSlideIndex < slides.value.length) {
+      return nextSlideIndex;
+    }
+    return 0;
+  });
+  const previousIndex = computed(() => {
+    const previousSlideIndex = currentIndex.value - 1;
+    if (previousSlideIndex >= 0) {
+      return previousSlideIndex;
+    }
+    return slides.value.length - 1;
+  });
+  const goToSlide = (index) => {
+    embla.value.scrollTo(index);
+  };
+  const handleUserInteraction = async (index, interactionType) => {
+    if (index !== null && typeof index !== "undefined") {
+      await nextTick();
+      goToSlide(index);
+    }
+    emit("interact-carousel", interactionType);
+  };
+  const slideIndicatorListLength = () => {
+    const indicator = embla.value ? embla.value.scrollSnapList().length : 0;
+    slideIndicatorCount.value = indicator;
+    return indicator;
+  };
+  const reInitVisible = () => {
+    const slidesInView = embla.value.slidesInView(true).length;
+    if (slidesInView) {
+      embla.value.reInit({
+        slidesToScroll: slidesInView,
+        inViewThreshold: 0.9
+      });
+    }
+  };
+  const reInit = () => {
+    embla.value.reInit();
+    if (slidesToScroll.value === "visible") {
+      reInitVisible();
+    }
+    slides.value = embla.value.slideNodes();
+    slideIndicatorListLength();
+  };
+  const onCarouselContainerClick = (e) => {
+    if (embla.value && !embla.value.clickAllowed()) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+  };
+  const isAriaHidden = (index) => {
+    if (embla.value) {
+      return !embla.value.slidesInView(true).includes(index);
+    }
+    return false;
+  };
+  onMounted(async () => {
+    var _a2;
+    embla.value = EmblaCarousel(rootEl.value, {
+      loop: true,
+      containScroll: "trimSnaps",
+      inViewThreshold: 0.9,
+      align: "start",
+      ...extraEmblaOptions,
+      ...emblaOptions.value
+    });
+    if (slidesToScroll.value === "visible") {
+      reInitVisible();
+      embla.value.on(
+        "resize",
+        throttle(() => {
+          embla.value.reInit({
+            slidesToScroll: embla.value.slidesInView(true).length || "auto",
+            inViewThreshold: 0.9
+          });
+          slides.value = embla.value.slideNodes();
+          slideIndicatorListLength();
+        }, 250)
+      );
+    }
+    slides.value = embla.value.slideNodes();
+    slideIndicatorListLength();
+    (_a2 = embla == null ? void 0 : embla.value) == null ? void 0 : _a2.on("select", () => {
+      currentIndex.value = embla.value.selectedScrollSnap();
+      nextTick(() => {
+        emit("change", currentIndex);
+      });
+    });
+  });
+  onUnmounted(async () => {
+    var _a2, _b;
+    (_a2 = embla == null ? void 0 : embla.value) == null ? void 0 : _a2.off("select");
+    (_b = embla == null ? void 0 : embla.value) == null ? void 0 : _b.destroy();
+  });
+  return {
+    rootEl,
+    embla,
+    slides,
+    currentIndex,
+    componentSlotKeys,
+    nextIndex,
+    previousIndex,
+    slideIndicatorCount,
+    handleUserInteraction,
+    goToSlide,
+    reInit,
+    reInitVisible,
+    onCarouselContainerClick,
+    isAriaHidden,
+    slideIndicatorListLength
+  };
+}
+
+export {
+  carouselUtil
+};

package/dist/utils/chunk-B5J5WLAH.js

@@ -0,0 +1,18 @@
+// utils/printing.js
+function lockPrintSingleEl(domNode) {
+  if (typeof window !== "undefined" && domNode) {
+    document.body.classList.add("print:tw-invisible", "print:tw-overflow-hidden");
+    domNode.classList.add("print:tw-visible", "print:tw-overflow-auto");
+  }
+}
+function unlockPrintSingleEl(domNode) {
+  if (typeof window !== "undefined" && domNode) {
+    document.body.classList.remove("print:tw-invisible", "print:tw-overflow-hidden");
+    domNode.classList.remove("print:tw-visible", "print:tw-overflow-auto");
+  }
+}
+
+export {
+  lockPrintSingleEl,
+  unlockPrintSingleEl
+};

package/dist/utils/chunk-GPSH6OPA.js

@@ -0,0 +1,64 @@
+// utils/Alea.js
+function Mash() {
+  let n = 4022871197;
+  const mash = function(data) {
+    data = data.toString();
+    for (let i = 0; i < data.length; i++) {
+      n += data.charCodeAt(i);
+      let h = 0.02519603282416938 * n;
+      n = h >>> 0;
+      h -= n;
+      h *= n;
+      n = h >>> 0;
+      h -= n;
+      n += h * 4294967296;
+    }
+    return (n >>> 0) * 23283064365386963e-26;
+  };
+  mash.version = "Mash 0.9";
+  return mash;
+}
+function Alea() {
+  return function(args) {
+    let s0 = 0;
+    let s1 = 0;
+    let s2 = 0;
+    let c = 1;
+    if (args.length === 0) {
+      args = [+/* @__PURE__ */ new Date()];
+    }
+    let mash = Mash();
+    s0 = mash(" ");
+    s1 = mash(" ");
+    s2 = mash(" ");
+    for (let i = 0; i < args.length; i++) {
+      s0 -= mash(args[i]);
+      if (s0 < 0) {
+        s0 += 1;
+      }
+      s1 -= mash(args[i]);
+      if (s1 < 0) {
+        s1 += 1;
+      }
+      s2 -= mash(args[i]);
+      if (s2 < 0) {
+        s2 += 1;
+      }
+    }
+    mash = null;
+    const random = function() {
+      const t = 2091639 * s0 + c * 23283064365386963e-26;
+      s0 = s1;
+      s1 = s2;
+      return s2 = t - (c = t | 0);
+    };
+    random.version = "Alea 0.9";
+    random.args = args;
+    return random;
+  }(Array.prototype.slice.call(arguments));
+}
+
+export {
+  Mash,
+  Alea
+};

package/dist/utils/chunk-HIY5IW65.js

@@ -0,0 +1,28 @@
+// utils/scrollLock.js
+function lockScroll() {
+  if (typeof window !== "undefined") {
+    document.body.style.overflow = "hidden";
+  }
+}
+function unlockScroll() {
+  if (typeof window !== "undefined") {
+    document.body.style.overflow = null;
+  }
+}
+function lockScrollSmallOnly() {
+  if (typeof window !== "undefined") {
+    document.body.classList.add("tw-overflow-hidden", "md:tw-overflow-auto");
+  }
+}
+function unlockScrollSmallOnly() {
+  if (typeof window !== "undefined") {
+    document.body.classList.remove("tw-overflow-hidden", "md:tw-overflow-auto");
+  }
+}
+
+export {
+  lockScroll,
+  unlockScroll,
+  lockScrollSmallOnly,
+  unlockScrollSmallOnly
+};

package/dist/utils/chunk-HV3AUBFT.js

@@ -0,0 +1,15 @@
+// utils/throttle.js
+function throttle(func, timeFrame) {
+  let lastTime = 0;
+  return function t(...args) {
+    const now = /* @__PURE__ */ new Date();
+    if (now - lastTime >= timeFrame) {
+      func(...args);
+      lastTime = now;
+    }
+  };
+}
+
+export {
+  throttle
+};

package/dist/utils/chunk-MSMZIN54.js

@@ -0,0 +1,110 @@
+// utils/treemap.js
+var getMaximum = (array) => Math.max(...array);
+var getMinimum = (array) => Math.min(...array);
+var sumReducer = (acc, cur) => acc + cur;
+var roundValue = (number) => Math.max(Math.round(number * 100) / 100, 0);
+var validateArguments = ({ data, width, height }) => {
+  if (!width || typeof width !== "number" || width < 0) {
+    throw new Error("You need to specify the width of your treemap");
+  }
+  if (!height || typeof height !== "number" || height < 0) {
+    throw new Error("You need to specify the height of your treemap");
+  }
+  if (!data || !Array.isArray(data) || data.length === 0 || !data.every((dataPoint) => Object.prototype.hasOwnProperty.call(dataPoint, "value") && typeof dataPoint.value === "number" && dataPoint.value >= 0 && !Number.isNaN(dataPoint.value))) {
+    throw new Error("You data must be in this format [{ value: 1 }, { value: 2 }], 'value' being a positive number");
+  }
+};
+function getTreemap({ data, width, height }) {
+  let Rectangle = {};
+  let initialData = [];
+  function worstRatio(row, width2) {
+    const sum = row.reduce(sumReducer, 0);
+    const rowMax = getMaximum(row);
+    const rowMin = getMinimum(row);
+    return Math.max(width2 ** 2 * rowMax / sum ** 2, sum ** 2 / (width2 ** 2 * rowMin));
+  }
+  const getMinWidth = () => {
+    if (Rectangle.totalHeight ** 2 > Rectangle.totalWidth ** 2) {
+      return { value: Rectangle.totalWidth, vertical: false };
+    }
+    return { value: Rectangle.totalHeight, vertical: true };
+  };
+  const layoutRow = (row, width2, vertical) => {
+    const rowHeight = row.reduce(sumReducer, 0) / width2;
+    row.forEach((rowItem) => {
+      const rowWidth = rowItem / rowHeight;
+      const { xBeginning } = Rectangle;
+      const { yBeginning } = Rectangle;
+      let data2;
+      if (vertical) {
+        data2 = {
+          x: xBeginning,
+          y: yBeginning,
+          width: rowHeight,
+          height: rowWidth,
+          data: initialData[Rectangle.data.length]
+        };
+        Rectangle.yBeginning += rowWidth;
+      } else {
+        data2 = {
+          x: xBeginning,
+          y: yBeginning,
+          width: rowWidth,
+          height: rowHeight,
+          data: initialData[Rectangle.data.length]
+        };
+        Rectangle.xBeginning += rowWidth;
+      }
+      Rectangle.data.push(data2);
+    });
+    if (vertical) {
+      Rectangle.xBeginning += rowHeight;
+      Rectangle.yBeginning -= width2;
+      Rectangle.totalWidth -= rowHeight;
+    } else {
+      Rectangle.xBeginning -= width2;
+      Rectangle.yBeginning += rowHeight;
+      Rectangle.totalHeight -= rowHeight;
+    }
+  };
+  const layoutLastRow = (rows, children, width2) => {
+    const { vertical } = getMinWidth();
+    layoutRow(rows, width2, vertical);
+    layoutRow(children, width2, vertical);
+  };
+  const squarify = (children, row, width2) => {
+    if (children.length === 1) {
+      return layoutLastRow(row, children, width2);
+    }
+    const rowWithChild = [...row, children[0]];
+    if (row.length === 0 || worstRatio(row, width2) >= worstRatio(rowWithChild, width2)) {
+      children.shift();
+      return squarify(children, rowWithChild, width2);
+    }
+    layoutRow(row, width2, getMinWidth().vertical);
+    return squarify(children, [], getMinWidth().value);
+  };
+  validateArguments({ data, width, height });
+  Rectangle = {
+    data: [],
+    xBeginning: 0,
+    yBeginning: 0,
+    totalWidth: width,
+    totalHeight: height
+  };
+  initialData = data;
+  const totalValue = data.map((dataPoint) => dataPoint.value).reduce(sumReducer, 0);
+  const dataScaled = data.map((dataPoint) => dataPoint.value * height * width / totalValue);
+  squarify(dataScaled, [], getMinWidth().value);
+  return Rectangle.data.map((dataPoint) => ({
+    ...dataPoint,
+    x: roundValue(dataPoint.x),
+    y: roundValue(dataPoint.y),
+    width: roundValue(dataPoint.width),
+    height: roundValue(dataPoint.height)
+  }));
+}
+
+export {
+  getTreemap
+};

package/dist/utils/chunk-OXJCCNNW.js

@@ -0,0 +1,30 @@
+// utils/imageUtils.js
+function isLegacyPlaceholderAvatar(filename) {
+  if (!filename) {
+    return false;
+  }
+  let filenameCleaned = filename.toString();
+  if (filenameCleaned.includes(".")) {
+    [filenameCleaned] = filenameCleaned.split(".");
+  }
+  const defaultProfileIds = ["726677", "315726", "4d844ac2c0b77a8a522741b908ea5c32"];
+  return defaultProfileIds.includes(filenameCleaned);
+}
+function randomizedUserAvatarClass() {
+  const userCardStyleOptions = [
+    { color: "tw-text-action", bg: "tw-bg-brand-100" },
+    { color: "tw-text-black", bg: "tw-bg-brand-100" },
+    { color: "tw-text-white", bg: "tw-bg-action" },
+    { color: "tw-text-brand-100", bg: "tw-bg-action" },
+    { color: "tw-text-primary-inverse", bg: "tw-bg-action" },
+    { color: "tw-text-white", bg: "tw-bg-black" },
+    { color: "tw-text-action", bg: "tw-bg-black" }
+  ];
+  const randomStyle = userCardStyleOptions[Math.floor(Math.random() * userCardStyleOptions.length)];
+  return `${randomStyle.color} ${randomStyle.bg}`;
+}
+
+export {
+  isLegacyPlaceholderAvatar,
+  randomizedUserAvatarClass
+};

package/dist/utils/chunk-S3MABILA.js

@@ -0,0 +1,22 @@
+// utils/touchEvents.js
+function onBodyTouchstart(handler) {
+  [...document.body.children].forEach((child) => child.addEventListener("touchstart", handler));
+}
+function offBodyTouchstart(handler) {
+  [...document.body.children].forEach((child) => child.removeEventListener("touchstart", handler));
+}
+function isTargetElement(event, elements) {
+  const els = Array.isArray(elements) ? elements : [elements];
+  for (let i = 0; i < els.length; i += 1) {
+    if (els[i] === event.target || els[i].contains(event.target)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  onBodyTouchstart,
+  offBodyTouchstart,
+  isTargetElement
+};

package/dist/utils/chunk-VIGEMAKO.js

@@ -0,0 +1,249 @@
+// utils/mapUtils.js
+function getRandomInRange(from, to, fixed) {
+  return (Math.random() * (to - from) + from).toFixed(fixed) * 1;
+}
+var randomCoordinates = Array.from(
+  { length: 20 },
+  () => [getRandomInRange(-180, 180, 3), getRandomInRange(-90, 90, 3)]
+);
+var mapColors = [
+  100,
+  300,
+  500,
+  650,
+  800,
+  1e3
+];
+function getCoordinatesBetween(startCoordinates, endCoordinates, numberOfSteps) {
+  if (!startCoordinates || !endCoordinates || !numberOfSteps || numberOfSteps < 1 || !Array.isArray(startCoordinates) || !Array.isArray(endCoordinates) || startCoordinates.length !== 2 || endCoordinates.length !== 2) {
+    return [];
+  }
+  const diffX = endCoordinates[0] - startCoordinates[0];
+  const diffY = endCoordinates[1] - startCoordinates[1];
+  const sfX = diffX / numberOfSteps;
+  const sfY = diffY / numberOfSteps;
+  let i = 0;
+  let j = 0;
+  const lineCoordinates = [];
+  while (Math.abs(i) < Math.abs(diffX) || Math.abs(j) < Math.abs(diffY)) {
+    lineCoordinates.push([startCoordinates[0] + i, startCoordinates[1] + j]);
+    if (Math.abs(i) < Math.abs(diffX)) {
+      i += sfX;
+    }
+    if (Math.abs(j) < Math.abs(diffY)) {
+      j += sfY;
+    }
+  }
+  lineCoordinates[lineCoordinates.length - 1] = [endCoordinates[0], endCoordinates[1]];
+  return lineCoordinates;
+}
+function animateLines(mapInstance, originPoints, endPoint) {
+  const speedFactor = 100;
+  return new Promise((resolve) => {
+    mapInstance.addSource("endpoint", {
+      type: "geojson",
+      data: {
+        type: "Point",
+        coordinates: [
+          endPoint[0],
+          endPoint[1]
+        ]
+      }
+    });
+    const lineFlight = (startCoordinates, endCoordinates, index, lastLine = false) => {
+      const lineCoordinates = getCoordinatesBetween(startCoordinates, endCoordinates, speedFactor);
+      let animationCounter = 0;
+      const geojson = {
+        type: "FeatureCollection",
+        features: [{
+          type: "Feature",
+          geometry: {
+            type: "LineString",
+            coordinates: []
+          }
+        }]
+      };
+      mapInstance.addSource(`startPoint${index}`, {
+        type: "geojson",
+        data: {
+          type: "Point",
+          coordinates: [
+            startCoordinates[0],
+            startCoordinates[1]
+          ]
+        }
+      });
+      mapInstance.addLayer({
+        id: `line-animation${index}`,
+        type: "line",
+        source: {
+          type: "geojson",
+          data: geojson
+        },
+        layout: {
+          "line-cap": "round",
+          "line-join": "round"
+        },
+        paint: {
+          "line-color": "#277056",
+          "line-width": 2
+        }
+      });
+      const animateLine = () => {
+        if (animationCounter < lineCoordinates.length) {
+          geojson.features[0].geometry.coordinates.push(lineCoordinates[animationCounter]);
+          mapInstance.getSource(`line-animation${index}`).setData(geojson);
+          requestAnimationFrame(animateLine);
+          animationCounter += 1;
+        } else {
+          const coord = geojson.features[0].geometry.coordinates;
+          coord.shift();
+          coord.shift();
+          if (coord.length > 0) {
+            geojson.features[0].geometry.coordinates = coord;
+            mapInstance.getSource(`line-animation${index}`).setData(geojson);
+            requestAnimationFrame(animateLine);
+          } else {
+            mapInstance.removeLayer(`line-animation${index}`);
+            mapInstance.removeSource(`line-animation${index}`);
+            mapInstance.removeSource(`startPoint${index}`);
+            if (lastLine) {
+              mapInstance.removeSource("endpoint");
+              resolve();
+            }
+          }
+        }
+      };
+      animateLine();
+    };
+    originPoints.forEach((coordinate, index) => {
+      lineFlight(coordinate, endPoint, index, index === originPoints.length - 1);
+    });
+  });
+}
+function generateMapMarkers(mapInstance, borrowerPoints) {
+  const geojson = {
+    type: "FeatureCollection"
+  };
+  geojson.features = borrowerPoints.map((borrower) => ({
+    type: "Feature",
+    properties: {
+      message: "test",
+      image: borrower.image,
+      iconSize: [80, 80]
+    },
+    geometry: {
+      type: "Point",
+      coordinates: borrower.location
+    }
+  }));
+  geojson.features.forEach((marker) => {
+    const el = document.createElement("div");
+    el.className = "map-marker";
+    el.style.backgroundImage = `url(${marker.properties.image})`;
+    el.style.width = `${marker.properties.iconSize[0]}px`;
+    el.style.height = `${marker.properties.iconSize[1]}px`;
+    new maplibregl.Marker({ element: el }).setLngLat(marker.geometry.coordinates).addTo(mapInstance);
+  });
+}
+function animationCoordinator(mapInstance, borrowerPoints) {
+  return new Promise((resolve) => {
+    const destinationPoints = borrowerPoints.map((borrower) => borrower.location);
+    const totalNumberOfPoints = destinationPoints.length;
+    let currentPointIndex = 0;
+    const flyToPoint = (index) => {
+      mapInstance.flyTo({
+        // These options control the ending camera position: centered at
+        // the target, at zoom level 9, and north up.
+        center: destinationPoints[index],
+        zoom: 4,
+        bearing: 0,
+        // These options control the flight curve, making it move
+        // slowly and zoom out almost completely before starting
+        // to pan.
+        speed: 0.9,
+        // make the flying slow
+        curve: 1,
+        // change the speed at which it zooms out
+        // This can be any easing function: it takes a number between
+        // 0 and 1 and returns another number between 0 and 1.
+        easing(t) {
+          return t;
+        },
+        // this animation is considered essential with respect to prefers-reduced-motion
+        essential: true
+      }, { flyEnd: true });
+    };
+    mapInstance.on("moveend", (event) => {
+      if (event.flyEnd === true) {
+        animateLines(mapInstance, randomCoordinates, destinationPoints[currentPointIndex]).then(() => {
+          if (currentPointIndex < totalNumberOfPoints - 1) {
+            currentPointIndex += 1;
+            flyToPoint(currentPointIndex);
+          } else {
+            resolve();
+          }
+        });
+      }
+    });
+    flyToPoint(currentPointIndex);
+  });
+}
+var getLoansIntervals = (min, max, nbIntervals) => {
+  const size = Math.floor((max - min) / nbIntervals);
+  const result = [];
+  if (size <= 0)
+    return [[min, max]];
+  for (let i = 0; i < nbIntervals; i += 1) {
+    let inf = min + i * size;
+    let sup = inf + size < max ? inf + size : max;
+    if (i > 0) {
+      inf += 1 * i;
+      sup += 1 * i;
+    }
+    if (i > 0 && sup > max) {
+      sup = max;
+    }
+    if (i === nbIntervals - 1) {
+      if (sup < max || sup > max)
+        sup = max;
+    }
+    result.push([inf, sup]);
+    if (sup >= max)
+      break;
+  }
+  return result;
+};
+var getCountryColor = (lenderLoans, countriesData, kvTokensPrimitives) => {
+  const loanCountsArray = [];
+  countriesData.forEach((country) => {
+    loanCountsArray.push(country.value);
+  });
+  const maxNumLoansToOneCountry = Math.max(...loanCountsArray);
+  const intervals = getLoansIntervals(1, maxNumLoansToOneCountry, 6);
+  if (intervals.length === 1) {
+    const [inf, sup] = intervals[0];
+    for (let i = 0; i < sup; i += 1) {
+      const loansNumber = i + 1;
+      if (lenderLoans && lenderLoans >= loansNumber && lenderLoans < loansNumber + 1) {
+        return kvTokensPrimitives.colors.brand[mapColors[i]];
+      }
+    }
+  } else {
+    for (let i = 0; i < intervals.length; i += 1) {
+      const [inf, sup] = intervals[i];
+      if (lenderLoans && lenderLoans >= inf && lenderLoans <= sup) {
+        return kvTokensPrimitives.colors.brand[mapColors[i]];
+      }
+    }
+  }
+  return kvTokensPrimitives.colors.gray[300];
+};
+
+export {
+  getCoordinatesBetween,
+  generateMapMarkers,
+  animationCoordinator,
+  getLoansIntervals,
+  getCountryColor
+};