@kiva/kv-components 3.106.0 → 3.107.0

package/dist/mapUtils.js

@@ -0,0 +1,248 @@
+// 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 {
+  animationCoordinator,
+  generateMapMarkers,
+  getCoordinatesBetween,
+  getCountryColor,
+  getLoansIntervals
+};

package/dist/printing.cjs

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/printing.js
+var printing_exports = {};
+__export(printing_exports, {
+  lockPrintSingleEl: () => lockPrintSingleEl,
+  unlockPrintSingleEl: () => unlockPrintSingleEl
+});
+module.exports = __toCommonJS(printing_exports);
+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");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lockPrintSingleEl,
+  unlockPrintSingleEl
+});

package/dist/printing.js

@@ -0,0 +1,17 @@
+// 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/scrollLock.cjs

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/scrollLock.js
+var scrollLock_exports = {};
+__export(scrollLock_exports, {
+  lockScroll: () => lockScroll,
+  lockScrollSmallOnly: () => lockScrollSmallOnly,
+  unlockScroll: () => unlockScroll,
+  unlockScrollSmallOnly: () => unlockScrollSmallOnly
+});
+module.exports = __toCommonJS(scrollLock_exports);
+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");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lockScroll,
+  lockScrollSmallOnly,
+  unlockScroll,
+  unlockScrollSmallOnly
+});

package/dist/scrollLock.js

@@ -0,0 +1,27 @@
+// 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,
+  lockScrollSmallOnly,
+  unlockScroll,
+  unlockScrollSmallOnly
+};

package/dist/throttle.cjs

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/throttle.js
+var throttle_exports = {};
+__export(throttle_exports, {
+  throttle: () => throttle
+});
+module.exports = __toCommonJS(throttle_exports);
+function throttle(func, timeFrame) {
+  let lastTime = 0;
+  return function t(...args) {
+    const now = /* @__PURE__ */ new Date();
+    if (now - lastTime >= timeFrame) {
+      func(...args);
+      lastTime = now;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  throttle
+});

package/dist/throttle.js

@@ -0,0 +1,6 @@
+import {
+  throttle
+} from "./chunk-HV3AUBFT.js";
+export {
+  throttle
+};

package/dist/touchEvents.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/touchEvents.js
+var touchEvents_exports = {};
+__export(touchEvents_exports, {
+  isTargetElement: () => isTargetElement,
+  offBodyTouchstart: () => offBodyTouchstart,
+  onBodyTouchstart: () => onBodyTouchstart
+});
+module.exports = __toCommonJS(touchEvents_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTargetElement,
+  offBodyTouchstart,
+  onBodyTouchstart
+});

package/dist/touchEvents.js

@@ -0,0 +1,21 @@
+// 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 {
+  isTargetElement,
+  offBodyTouchstart,
+  onBodyTouchstart
+};

package/dist/treemap.cjs

@@ -0,0 +1,133 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/treemap.js
+var treemap_exports = {};
+__export(treemap_exports, {
+  getTreemap: () => getTreemap
+});
+module.exports = __toCommonJS(treemap_exports);
+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)
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTreemap
+});