@watermarkinsights/ripple 0.0.1 → 0.1.0-alpha.0

package/dist/collection/lang/piglatin.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const en = require("./en.json");
+
+const pig = {};
+Object.keys(en).map((k) => {
+  let string = en[k].defaultMessage;
+  const interpStart = string.indexOf("{");
+  const interpEnd = string.lastIndexOf("}") + 1;
+
+  // if there is an interpolation pattern
+  if (interpStart >= 0 && interpEnd > 2) {
+    let translInterp = translateSentence(string.slice(0, interpStart));
+
+    const interp = string.slice(interpStart, interpEnd);
+    // what's inside the braces shouldn't be translated
+    // unless it's in nested translated, and so on
+    // we can set flags to cut the string into pieces
+    // which should or should not be translated
+    const flags = [];
+    for (x = 0; x < interp.length; x++) {
+      if (interp[x] == "{") {
+        flags.push(x);
+      } else if (interp[x] == "}") {
+        flags.push(x);
+      }
+    }
+
+    splits = flags.map((_, i) => {
+      if (i < flags.length) return interp.slice(flags[i], flags[i + 1]);
+    });
+
+    splits.map((split, i) => {
+      translInterp += i % 2 ? translateSentence(split) : split; // only translate even ones (the odd ones are params)
+    });
+
+    translInterp += translateSentence(string.slice(interpEnd, string.length));
+
+    const dm = { defaultMessage: translInterp };
+    pig[k] = dm;
+  } else {
+    const dm = { defaultMessage: translateSentence(string) };
+    pig[k] = dm;
+  }
+});
+data = JSON.stringify(pig, null, 2);
+
+fs.writeFile("src/lang/pig.json", data, (err) => {
+  !!err && console.log(err);
+});
+
+function pigLatinize(word) {
+  const isVowel = (char) => ["a", "e", "i", "o", "u"].includes(char.toLowerCase());
+  const isLetter = (char) => RegExp(/^\p{L}/, "u").test(char);
+
+  const firstLetter = Array.from(word).reduce((l, char, i) => (isLetter(char) && l < 0 ? i : l), -1);
+
+  const lastLetter = Array.from(word).reduce((l, char, i) => (isLetter(char) ? i : l), -1);
+
+  if (firstLetter == -1 && lastLetter == -1) return word; // only special chars, don't translate
+
+  const specialKBefore = word.slice(0, firstLetter) || "";
+  const specialKAfter = word.slice(lastLetter + 1, word.length + 1) || "";
+  word = word.slice(firstLetter, lastLetter + 1) || "";
+
+  if (word) {
+    if (isVowel(word[0])) {
+      word += "yay";
+    } else {
+      const firstVowel = Array.from(word).reduce((firstV, char, i) => {
+        return isVowel(char) && firstV < 0 ? i : firstV;
+      }, -1);
+      if (word[0] == word[0].toUpperCase()) {
+        word =
+          word.substring(firstVowel, firstVowel + 1).toUpperCase() +
+          word.substring(firstVowel + 1, word.length) +
+          word.substring(0, firstVowel).toLowerCase() +
+          "ay";
+      } else {
+        word = word.substring(firstVowel, word.length) + word.substring(0, firstVowel) + "ay";
+      }
+    }
+  }
+  return specialKBefore + word + specialKAfter;
+}
+
+function pigifyIgnoringTags(word) {
+  const tagPattern = /<\/?[^>]+>/g;
+
+  const strippedText = word.replace(tagPattern, "");
+  const pigifiedText = pigLatinize(strippedText);
+  return word.replace(strippedText, pigifiedText);
+}
+
+function translateSentence(string) {
+  let words = string.split(" ");
+  return words
+    .reduce((acc, word) => {
+      return acc + " " + pigifyIgnoringTags(word);
+    }, "")
+    .substring(1); // rm leading space
+}

package/dist/esm/app-globals-d0ca31a6.js

@@ -0,0 +1,101 @@
+import './index-ef50bc01.js';
+
+const version = "0.1.0-alpha.0";
+
+// PRINT RIPPLE VERSION IN CONSOLE
+// test envs return 0 for plugin.length
+// do not print version number there as it causes issues
+if (window.navigator.plugins.length > 0) {
+    console.log("%cRipple component library %c%s", "color: #575195; font-weight: bold", "font-weight: bold", version);
+}
+// Dispatching events to track whether user is navigating with keyboard or mouse
+// no longer necessary for keyboard focus indicators (thanks to :focus-visible)
+// but still used in several components for other things (search for isTabbing)
+function wmComponentKeys(ev) {
+    if (ev.key == "Tab") {
+        var event = new Event("wmUserIsTabbing");
+        window.dispatchEvent(event);
+        document.querySelector("body").classList.add("wmcl-user-is-tabbing");
+    }
+    if (ev.key == "ArrowLeft" || ev.key == "ArrowUp" || ev.key == "ArrowRight" || ev.key == "ArrowDown") {
+        var event = new Event("wmUserIsKeying");
+        window.dispatchEvent(event);
+        document.querySelector("body").classList.add("wmcl-user-is-keying");
+    }
+}
+function wmComponentMouseDownOnce() {
+    var event = new Event("wmUserIsNotTabbing");
+    window.dispatchEvent(event);
+    document.querySelector("body").classList.remove("wmcl-user-is-tabbing");
+    document.querySelector("body").classList.remove("wmcl-user-is-keying");
+}
+window.addEventListener("keydown", wmComponentKeys);
+window.addEventListener("mousedown", wmComponentMouseDownOnce);
+// TOOLTIP
+// Add a tooltip element
+// This allows tooltips to be always at the highest stacking context (always on top)
+// Element is added withing a container to avoid performance impact
+const tooltipContainer = document.createElement("div");
+tooltipContainer.id = "wm-tooltip-container";
+const tooltipEl = document.createElement("div");
+tooltipEl.id = "wm-tooltip";
+tooltipEl.classList.add("wm-tooltip");
+tooltipEl.setAttribute("popover", "manual");
+tooltipEl.setAttribute("aria-hidden", "true");
+const tooltipStyles = document.createElement("style");
+tooltipStyles.textContent = `
+.wm-tooltip {
+  position: fixed;
+  overflow: hidden;
+  pointer-events: none;
+  line-height: normal;
+  font-family: inherit;
+  font-size: 0.875rem;
+  text-transform: none;
+  font-weight: normal;
+  background: var(--wmcolor-tooltip-background);
+  color: var(--wmcolor-tooltip-text);
+  z-index: 999999;
+  max-width: var(--wmTooltipMaxWidth, 13.75rem);
+  margin-right: 1.5rem;
+  padding: 0.375rem;
+  transition-property: opacity;
+  transition-delay: 0s;
+  opacity: 0;
+  inset: unset;
+  top: 0;
+  left: 0;
+  transform: translateZ(0);
+  will-change: transform;
+  transform: translate(var(--wmTooltipLeft), var(--wmTooltipTop));
+  border: none;
+}
+
+.wm-tooltip:popover-open {
+  opacity: 0;
+}
+
+.wm-tooltip.show {
+  transition-delay: 500ms;
+  opacity: 1;
+}
+`;
+const body = document.querySelector("body");
+if (body) {
+    document.head.appendChild(tooltipStyles);
+    tooltipContainer.appendChild(tooltipEl);
+    body.appendChild(tooltipContainer);
+}
+else {
+    document.addEventListener("DOMContentLoaded", () => {
+        const body = document.querySelector("body");
+        document.head.appendChild(tooltipStyles);
+        tooltipContainer.appendChild(tooltipEl);
+        body.appendChild(tooltipContainer);
+    });
+}
+const globalFn = () => { };
+
+const globalScripts = globalFn;
+
+export { globalScripts as g };

package/dist/{ripple/chartFunctions-CmeM8Tyx.js → esm/chartFunctions-4bc77b76.js}

@@ -1,5 +1,5 @@
-import { h } from './index-CU5QNCKv.js';
-import { i as intl, C as getPosition, v as checkForActiveElInShadow, D as safeMultiplyFloat } from './functions-DVLl0rH_.js';
+import { h } from './index-ef50bc01.js';
+import { i as intl, c as checkForActiveElInShadow, e as safeMultiplyFloat, f as getPosition } from './functions-de887809.js';
 
 const colors = {
     salmon: "#ff5f4e",
@@ -180,6 +180,7 @@ function handleSliceKeyDown(ev) {
 }
 function handleSliceClick(ev, s) {
     if (this.popoverEl && !this.isTabbing) {
+        this.componentWrapperEl.classList.toggle("interactive-popover", !!s.buttonText);
         s.coords = { x: ev.clientX, y: ev.clientY };
         openPopover(this.popoverEl, s);
         highlightSegmentInfo(Array.from(this.el.shadowRoot.querySelectorAll("[data-segmentindex")), s);
@@ -187,6 +188,7 @@ function handleSliceClick(ev, s) {
 }
 function handleSliceFocus(ev, s) {
     if (this.popoverEl && this.isTabbing) {
+        this.componentWrapperEl.classList.toggle("interactive-popover", !!s.buttonText);
         this.focusedSliceId = s.id;
         s.coords = getPosition(ev.target);
         s.coords.x = s.coords.x + 30;
@@ -721,5 +723,161 @@ function renderHiddenValuesMessage() {
         h("br", null),
         seeDetailsMessage));
 }
+function formatDisplayValue(amount, amountTotal, valueFormat, decimalPlaces = 0) {
+    switch (valueFormat) {
+        case "amount":
+            return amount.toFixed(decimalPlaces);
+        case "percentage":
+            const percentage = (amount / amountTotal) * 100;
+            if (amount > 0 && percentage < 1)
+                return "<1%";
+            if (percentage > 99 && amount !== amountTotal)
+                return ">99%";
+            return `${Math.round(percentage).toFixed(0)}%`;
+        default:
+        case "none":
+            return "";
+    }
+}
+function isNiceInterval(interval, niceValues = [1, 1.5, 2, 2.5, 3, 5, 10]) {
+    const magnitude = Math.pow(10, Math.floor(Math.log10(interval)));
+    const normalized = interval / magnitude;
+    const normalizedComparision = niceValues.some((nice) => Math.abs(normalized - nice) < 0.0001); // check equality with floating point tolerance
+    return normalizedComparision;
+}
+function inferDecimalPlacesFromFloat(value) {
+    // Trims floating point noise and returns significant decimal places, or return 2 for non-terminating values (2/3)
+    if (value === 0 || !Number.isFinite(value))
+        return 0;
+    const maxPlaces = 15;
+    let scaled = Math.abs(value);
+    for (let n = 0; n <= maxPlaces; n++) {
+        // Each iteration, compare the scaled value to the nearest whole number
+        // If the difference is less than the noise margin, return the number of times scaled (decimal places)
+        // Otherwise scale up by 10 and loop
+        const nearest = Math.round(scaled);
+        const noiseMargin = 1e-9;
+        if (Math.abs(scaled - nearest) < noiseMargin) {
+            return n;
+        }
+        scaled *= 10;
+    }
+    return 2;
+}
+function inferDecimalPlacesForUnitValue(value) {
+    // Works with units K and M. Returns decimal places taking unit conversion into account
+    if (value === 0 || !Number.isFinite(value))
+        return 0;
+    const abs = Math.abs(value);
+    let displayUnitValue = abs;
+    if (abs >= 1000000) {
+        displayUnitValue = abs / 1000000;
+    }
+    else if (abs >= 1000) {
+        displayUnitValue = abs / 1000;
+    }
+    return Math.max(inferDecimalPlacesFromFloat(abs), inferDecimalPlacesFromFloat(displayUnitValue));
+}
+function suffixNumber(value, decimalPlaces) {
+    const hasDecimalPlaces = decimalPlaces !== undefined;
+    if (value >= 1000000) {
+        const scaled = value / 1000000;
+        if (hasDecimalPlaces) {
+            return `${scaled.toFixed(decimalPlaces)}M`;
+        }
+        return `${scaled.toFixed(value % 1000000 === 0 ? 0 : 1)}M`;
+    }
+    if (value >= 1000) {
+        const scaled = value / 1000;
+        if (hasDecimalPlaces) {
+            return `${scaled.toFixed(decimalPlaces)}K`;
+        }
+        return `${scaled.toFixed(value % 1000 === 0 ? 0 : 1)}K`;
+    }
+    if (hasDecimalPlaces) {
+        return value.toFixed(decimalPlaces);
+    }
+    return value.toString();
+}
+function findLargestNiceInterval(maxIntervals, total) {
+    // Given a max number of intervals and a total, iterate down until a nice way to divide the total is found.
+    // Otherwise, return 1 interval
+    for (let intervals = maxIntervals; intervals >= 1; intervals--) {
+        const candidateInterval = total / intervals;
+        if (isNiceInterval(candidateInterval)) {
+            return { numIntervals: intervals, interval: candidateInterval };
+        }
+    }
+    return { numIntervals: 1, interval: total };
+}
+function findNiceRoundNumber(value) {
+    // Given a value, find the next "nice" round number >= that value.
+    // Examples: 982 → 1000, 45 → 50, 1234 → 1500, 7 → 10
+    if (value <= 0)
+        return 0;
+    const niceValues = [1, 1.5, 2, 2.5, 3, 5, 10];
+    const magnitude = Math.pow(10, Math.floor(Math.log10(value)));
+    const normalized = value / magnitude;
+    // Find the smallest nice value that is >= the normalized value
+    for (const nice of niceValues) {
+        if (nice >= normalized) {
+            return nice * magnitude;
+        }
+    }
+    // Fallback: next order of magnitude
+    return 10 * magnitude;
+}
+function computeLegendData(data) {
+    const seen = new Set();
+    const result = [];
+    data.forEach((groupItems) => {
+        groupItems.forEach((item) => {
+            if (!seen.has(item.barLegend)) {
+                seen.add(item.barLegend);
+                result.push(item);
+            }
+        });
+    });
+    return result;
+}
+function groupProcessedData(data, defaultGroupName) {
+    const groups = new Map();
+    data.forEach((item) => {
+        let groupName = item.groupName;
+        if (!groupName) {
+            groupName = defaultGroupName;
+        }
+        if (!groups.has(groupName)) {
+            groups.set(groupName, []);
+        }
+        groups.get(groupName).push(item);
+    });
+    return groups;
+}
+function sortGroupedData(data) {
+    const barData = [...data];
+    // Determine group order and barLegend order by first occurrences
+    const groupOrder = [];
+    barData.forEach((item) => {
+        if (item.groupName && !groupOrder.includes(item.groupName)) {
+            groupOrder.push(item.groupName);
+        }
+    });
+    const barLegendOrder = barData
+        .filter((item) => item.groupName === groupOrder[0])
+        .map((item) => item.barLegend);
+    // Two step sorting: sort by group order, then by barLegend order
+    const sortedBarData = barData.sort((a, b) => {
+        const groupIndexA = groupOrder.indexOf(a.groupName || "");
+        const groupIndexB = groupOrder.indexOf(b.groupName || "");
+        if (groupIndexA !== groupIndexB) {
+            return groupIndexA - groupIndexB;
+        }
+        const legendIndexA = barLegendOrder.indexOf(a.barLegend);
+        const legendIndexB = barLegendOrder.indexOf(b.barLegend);
+        return legendIndexA - legendIndexB;
+    });
+    return sortedBarData;
+}
 
-export { allChartsDetails as a, amountToPercent as b, renderSimpleBar as c, renderStackedBar as d, renderDoughnut as e, exitChart as f, getDetails as g, handleChartKeydown as h, renderLegend as i, renderHiddenValuesMessage as j, renderInstructionsText as k, getInterval as l, abbrNumber as m, renderCompletionMessage as n, renderLegendItem as o, removeSegmentInfoHighlight as r };
+export { allChartsDetails as a, renderSimpleBar as b, renderStackedBar as c, renderDoughnut as d, renderInstructionsText as e, renderLegend as f, getDetails as g, handleChartKeydown as h, renderHiddenValuesMessage as i, exitChart as j, amountToPercent as k, renderCompletionMessage as l, renderLegendItem as m, findNiceRoundNumber as n, groupProcessedData as o, computeLegendData as p, formatDisplayValue as q, removeSegmentInfoHighlight as r, sortGroupedData as s, findLargestNiceInterval as t, suffixNumber as u, getMaxTicks as v, inferDecimalPlacesForUnitValue as w, getInterval as x };