@watermarkinsights/ripple 3.27.0 → 3.27.1

package/dist/esm/{global-7ee0d78d.js → global-2c7bbfe6.js}

@@ -1,74 +1,74 @@
-const version = "3.27.0";
+const version = "3.27.1";
 
-// 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("Ripple component library", version);
-}
-// USER-IS-TABBING CLASSES (FOR FOCUS INDICATORS)
-// Dispatching events to track whether user is navigating with keyboard or mouse
-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.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: black;
-  color: #fff;
-  z-index: 999999;
-  max-width: var(--wmTooltipMaxWidth, 13.75rem);
-  margin-right: 1.5rem;
-  padding: 0.375rem;
-  transition-property: opacity;
-  transition-delay: 0s;
-  opacity: 0;
-  top: 0;
-  left: 0;
-  transform: translateZ(0);
-  will-change: transform;
-  transform: translate(var(--wmTooltipLeft), var(--wmTooltipTop));
-}
-
-#wm-tooltip.show {
-  transition-delay: 500ms;
-  opacity: 1;
-}
-`;
-document.head.appendChild(tooltipStyles);
-tooltipContainer.appendChild(tooltipEl);
+// 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("Ripple component library", version);
+}
+// USER-IS-TABBING CLASSES (FOR FOCUS INDICATORS)
+// Dispatching events to track whether user is navigating with keyboard or mouse
+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.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: black;
+  color: #fff;
+  z-index: 999999;
+  max-width: var(--wmTooltipMaxWidth, 13.75rem);
+  margin-right: 1.5rem;
+  padding: 0.375rem;
+  transition-property: opacity;
+  transition-delay: 0s;
+  opacity: 0;
+  top: 0;
+  left: 0;
+  transform: translateZ(0);
+  will-change: transform;
+  transform: translate(var(--wmTooltipLeft), var(--wmTooltipTop));
+}
+
+#wm-tooltip.show {
+  transition-delay: 500ms;
+  opacity: 1;
+}
+`;
+document.head.appendChild(tooltipStyles);
+tooltipContainer.appendChild(tooltipEl);
 document.querySelector("body").appendChild(tooltipContainer);

package/dist/esm/{http-service-5d037e16.js → http-service-3dc3b3e7.js}

@@ -1,52 +1,52 @@
-const getRequest = async (url) => {
-  const response = await fetch(url);
-  if (!!response && !!response.ok) {
-    return await response.json();
-  }
-  else {
-    throw new Error(response.statusText);
-  }
-};
-const postRequest = async (url, payload) => {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json; charset=utf-8" },
-    body: JSON.stringify(payload),
-  });
-  if (!!response && !!response.ok) {
-    return await response.json();
-  }
-  else {
-    throw new Error(response.statusText);
-  }
-};
-const deleteRequest = async (url) => {
-  const response = await fetch(url, { method: "DELETE" });
-  if (!!response && !!response.ok) {
-    return await response.json();
-  }
-  else {
-    throw new Error(response.statusText);
-  }
-};
-const putRequest = (url, file, onProgress) => {
-  return new Promise((resolve, reject) => {
-    // there's no way to track progress with the fetch API, so using XHR
-    const req = new XMLHttpRequest();
-    req.upload.addEventListener("progress", (ev) => onProgress(ev));
-    req.addEventListener("readystatechange", function () {
-      if (this.readyState === 4 && this.status === 200) {
-        resolve(this);
-      }
-      else if (this.readyState === 4 && this.status !== 200) {
-        reject();
-      }
-    });
-    req.onerror = () => reject();
-    req.open("PUT", url, true);
-    req.setRequestHeader("Content-Disposition", `attachment;filename="${file.name}"`);
-    req.send(file);
-  });
+const getRequest = async (url) => {
+  const response = await fetch(url);
+  if (!!response && !!response.ok) {
+    return await response.json();
+  }
+  else {
+    throw new Error(response.statusText);
+  }
+};
+const postRequest = async (url, payload) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    body: JSON.stringify(payload),
+  });
+  if (!!response && !!response.ok) {
+    return await response.json();
+  }
+  else {
+    throw new Error(response.statusText);
+  }
+};
+const deleteRequest = async (url) => {
+  const response = await fetch(url, { method: "DELETE" });
+  if (!!response && !!response.ok) {
+    return await response.json();
+  }
+  else {
+    throw new Error(response.statusText);
+  }
+};
+const putRequest = (url, file, onProgress) => {
+  return new Promise((resolve, reject) => {
+    // there's no way to track progress with the fetch API, so using XHR
+    const req = new XMLHttpRequest();
+    req.upload.addEventListener("progress", (ev) => onProgress(ev));
+    req.addEventListener("readystatechange", function () {
+      if (this.readyState === 4 && this.status === 200) {
+        resolve(this);
+      }
+      else if (this.readyState === 4 && this.status !== 200) {
+        reject();
+      }
+    });
+    req.onerror = () => reject();
+    req.open("PUT", url, true);
+    req.setRequestHeader("Content-Disposition", `attachment;filename="${file.name}"`);
+    req.send(file);
+  });
 };
 
 export { postRequest as a, deleteRequest as d, getRequest as g, putRequest as p };

package/dist/esm/{interfaces-61c6305b.js → interfaces-2b97fab2.js}

@@ -1,32 +1,32 @@
-//List of icon codes with more indicative descriptors to create labels for icon-only buttons
-function getIconCodeFromName(icon) {
-  return iconCodes[icon] || icon;
-}
-const iconCodes = {
-  close: "f156",
-  pencil: "f3eb",
-  cancel: "f739",
-  check: "f12c",
-  delete: "f1c0",
-  magnify: "f349",
-  export: "f207",
-  "dots-vertical": "f1d9",
-  "arrow-left": "f04d",
-  "arrow-right": "f054",
-  "chevron-left": "f141",
-  "chevron-right": "f142",
-  "menu-left": "f35e",
-  "menu-down": "f35d",
-  "keyboard-backspace": "f30d",
-  "file-tree": "f645",
-  "sort-alphabetical": "f4bb",
-  "checkbox-marked-circle": "f133",
-  "account-settings": "f630",
-  "backup-restore": "f06f",
-};
-const defaultMode = "planning";
-const getWmMode = (ref) => {
-  return ref.getAttribute("mode") || document.documentElement.getAttribute("mode") || defaultMode;
+//List of icon codes with more indicative descriptors to create labels for icon-only buttons
+function getIconCodeFromName(icon) {
+  return iconCodes[icon] || icon;
+}
+const iconCodes = {
+  close: "f156",
+  pencil: "f3eb",
+  cancel: "f739",
+  check: "f12c",
+  delete: "f1c0",
+  magnify: "f349",
+  export: "f207",
+  "dots-vertical": "f1d9",
+  "arrow-left": "f04d",
+  "arrow-right": "f054",
+  "chevron-left": "f141",
+  "chevron-right": "f142",
+  "menu-left": "f35e",
+  "menu-down": "f35d",
+  "keyboard-backspace": "f30d",
+  "file-tree": "f645",
+  "sort-alphabetical": "f4bb",
+  "checkbox-marked-circle": "f133",
+  "account-settings": "f630",
+  "backup-restore": "f06f",
+};
+const defaultMode = "planning";
+const getWmMode = (ref) => {
+  return ref.getAttribute("mode") || document.documentElement.getAttribute("mode") || defaultMode;
 };
 
 export { getWmMode as a, getIconCodeFromName as g };

package/dist/esm/{intl-d101e1a9.js → intl-ffbca53d.js}

@@ -1,135 +1,135 @@
-import { i as intl } from './functions-f32b1ca4.js';
+import { i as intl } from './functions-cbb19d50.js';
 
-const globalMessages = {
-  characterLimitReached: intl.formatMessage({
-    id: "global.characterLimitReached",
-    defaultMessage: "No additional characters will be entered.",
-    description: "for screen readers",
-  }),
-  close: intl.formatMessage({
-    id: "global.closeVerb",
-    defaultMessage: "Close",
-    description: "For a button, to close a user interface element",
-  }),
-  genericError: intl.formatMessage({
-    id: "global.genericError",
-    defaultMessage: "An error occurred. Please try again.",
-  }),
-  newWindow: intl.formatMessage({
-    id: "global.newWindowLink",
-    defaultMessage: "Opens in a new window.",
-    description: "Indicates that a focused link will open in a new window",
-  }),
-  next: intl.formatMessage({
-    id: "global.next",
-    defaultMessage: "next",
-    description: "Button text, indicating an action leading to a 'next' state",
-  }),
-  open: intl.formatMessage({
-    id: "global.openVerb",
-    defaultMessage: "Open",
-    description: "For a button, to open a user interface element",
-  }),
-  previous: intl.formatMessage({
-    id: "global.previous",
-    defaultMessage: "previous",
-    description: "Button text, indicating an action leading to a 'previous' state",
-  }),
-  requiredError: intl.formatMessage({
-    id: "global.requiredError",
-    defaultMessage: "This field is required.",
-    description: "Error displayed under a required field when it has not been filled",
-  }),
-  requiredField: intl.formatMessage({
-    id: "global.requiredField",
-    defaultMessage: "required field",
-    description: "Screen reader text, indicating the currently focused field is required",
-  }),
-  // -------------------------------------------------------------------------- //
-  //                             Functions                                      //
-  // -------------------------------------------------------------------------- //
-  getCharactersEntered: (charCount, charLimit) => intl.formatMessage({
-    id: "global.charactersEntered",
-    defaultMessage: "{x, number} of {y, number} characters entered.",
-    description: "for screen readers",
-  }, { x: charCount, y: charLimit }),
-  getCharacterLimit: (characterLimit) => intl.formatMessage({
-    id: "global.characterLimit",
-    defaultMessage: "{limit, number} characters allowed.",
-    description: "for screen readers",
-  }, { limit: characterLimit }),
-};
-const uploaderMessages = {
-  duplicateName: intl.formatMessage({
-    id: "uploader.duplicateName",
-    defaultMessage: "A file with this name already exists.",
-  }),
-  fileLimitExceeded: intl.formatMessage({
-    id: "uploader.fileUploadLimitExceeded",
-    defaultMessage: "Upload unsuccessful because file selection would exceed the maximum number of files",
-    description: "Message displayed when trying to upload too many files",
-  }),
-  fileLimitReached: intl.formatMessage({
-    id: "uploader.fileUploadLimitReached",
-    defaultMessage: "The maximum number of files has been reached",
-    description: "Message displayed when trying to upload additional files, but the limit has been reached",
-  }),
-  finishedUploading: intl.formatMessage({
-    id: "uploader.finishedUploading",
-    defaultMessage: "Finished uploading",
-  }),
-  waitToUpload: intl.formatMessage({
-    id: "uploader.waitToUpload",
-    defaultMessage: "Please wait for current upload to complete before uploading new files.",
-    description: "Message for screen reader users",
-  }),
-  zeroFileSize: intl.formatMessage({
-    id: "uploader.zeroFileSize",
-    defaultMessage: "The file must be more than 0 bytes",
-    description: "Error message when user attempts to upload a file of no size",
-  }),
-  // -------------------------------------------------------------------------- //
-  //                             Functions                                      //
-  // -------------------------------------------------------------------------- //
-  getAcceptedFileTypes: (validTypes, amount) => intl.formatMessage({
-    id: "uploader.acceptedFileTypes",
-    defaultMessage: "Accepted file {amount, plural, =1 {type} other {types}}: {fileTypes}",
-  }, {
-    fileTypes: validTypes,
-    amount: amount,
-  }),
-  getFilesAdded: (numFiles) => intl.formatMessage({
-    id: "uploader.filesAdded",
-    defaultMessage: "{numFiles, plural, one {1 file added} other {# files added}}",
-  }, { numFiles: numFiles }),
-  getFileCount: (fileListLength, maxFiles) => intl.formatMessage({
-    id: "uploader.fileCount",
-    defaultMessage: "{x} of {y} Files",
-    description: "A count of the number of files currently uploaded",
-  }, { x: fileListLength, y: maxFiles }),
-  getFileTooLarge: (maxSize) => intl.formatMessage({
-    id: "uploader.fileTooLarge",
-    defaultMessage: "The selected file is too large. Maximum file size is {size}Mb",
-  }, { size: maxSize }),
-  getFilesUploading: (numFilesUploading) => intl.formatMessage({
-    id: "uploader.filesUploading",
-    defaultMessage: "{num, plural, one {1 file uploading} other {# files uploading}}",
-  }, { num: numFilesUploading }),
-  getInvalidFileType: (validTypes) => intl.formatMessage({
-    id: "uploader.invalidFileType",
-    defaultMessage: "The file type is invalid. Accepted types: {validTypes}",
-  }, { validTypes }),
-  getMaxSize: (maxSize) => intl.formatMessage({
-    id: "uploader.maxSize",
-    defaultMessage: "Maximum file size {maxSize}MB",
-    description: "An indicator of the maximum file size the uploader allows",
-  }, {
-    maxSize: maxSize,
-  }),
-  getUploadProgress: (percentage) => intl.formatMessage({
-    id: "uploader.uploadProgress",
-    defaultMessage: "Upload progress: {percentage}%",
-  }, { percentage: percentage }),
+const globalMessages = {
+  characterLimitReached: intl.formatMessage({
+    id: "global.characterLimitReached",
+    defaultMessage: "No additional characters will be entered.",
+    description: "for screen readers",
+  }),
+  close: intl.formatMessage({
+    id: "global.closeVerb",
+    defaultMessage: "Close",
+    description: "For a button, to close a user interface element",
+  }),
+  genericError: intl.formatMessage({
+    id: "global.genericError",
+    defaultMessage: "An error occurred. Please try again.",
+  }),
+  newWindow: intl.formatMessage({
+    id: "global.newWindowLink",
+    defaultMessage: "Opens in a new window.",
+    description: "Indicates that a focused link will open in a new window",
+  }),
+  next: intl.formatMessage({
+    id: "global.next",
+    defaultMessage: "next",
+    description: "Button text, indicating an action leading to a 'next' state",
+  }),
+  open: intl.formatMessage({
+    id: "global.openVerb",
+    defaultMessage: "Open",
+    description: "For a button, to open a user interface element",
+  }),
+  previous: intl.formatMessage({
+    id: "global.previous",
+    defaultMessage: "previous",
+    description: "Button text, indicating an action leading to a 'previous' state",
+  }),
+  requiredError: intl.formatMessage({
+    id: "global.requiredError",
+    defaultMessage: "This field is required.",
+    description: "Error displayed under a required field when it has not been filled",
+  }),
+  requiredField: intl.formatMessage({
+    id: "global.requiredField",
+    defaultMessage: "required field",
+    description: "Screen reader text, indicating the currently focused field is required",
+  }),
+  // -------------------------------------------------------------------------- //
+  //                             Functions                                      //
+  // -------------------------------------------------------------------------- //
+  getCharactersEntered: (charCount, charLimit) => intl.formatMessage({
+    id: "global.charactersEntered",
+    defaultMessage: "{x, number} of {y, number} characters entered.",
+    description: "for screen readers",
+  }, { x: charCount, y: charLimit }),
+  getCharacterLimit: (characterLimit) => intl.formatMessage({
+    id: "global.characterLimit",
+    defaultMessage: "{limit, number} characters allowed.",
+    description: "for screen readers",
+  }, { limit: characterLimit }),
+};
+const uploaderMessages = {
+  duplicateName: intl.formatMessage({
+    id: "uploader.duplicateName",
+    defaultMessage: "A file with this name already exists.",
+  }),
+  fileLimitExceeded: intl.formatMessage({
+    id: "uploader.fileUploadLimitExceeded",
+    defaultMessage: "Upload unsuccessful because file selection would exceed the maximum number of files",
+    description: "Message displayed when trying to upload too many files",
+  }),
+  fileLimitReached: intl.formatMessage({
+    id: "uploader.fileUploadLimitReached",
+    defaultMessage: "The maximum number of files has been reached",
+    description: "Message displayed when trying to upload additional files, but the limit has been reached",
+  }),
+  finishedUploading: intl.formatMessage({
+    id: "uploader.finishedUploading",
+    defaultMessage: "Finished uploading",
+  }),
+  waitToUpload: intl.formatMessage({
+    id: "uploader.waitToUpload",
+    defaultMessage: "Please wait for current upload to complete before uploading new files.",
+    description: "Message for screen reader users",
+  }),
+  zeroFileSize: intl.formatMessage({
+    id: "uploader.zeroFileSize",
+    defaultMessage: "The file must be more than 0 bytes",
+    description: "Error message when user attempts to upload a file of no size",
+  }),
+  // -------------------------------------------------------------------------- //
+  //                             Functions                                      //
+  // -------------------------------------------------------------------------- //
+  getAcceptedFileTypes: (validTypes, amount) => intl.formatMessage({
+    id: "uploader.acceptedFileTypes",
+    defaultMessage: "Accepted file {amount, plural, =1 {type} other {types}}: {fileTypes}",
+  }, {
+    fileTypes: validTypes,
+    amount: amount,
+  }),
+  getFilesAdded: (numFiles) => intl.formatMessage({
+    id: "uploader.filesAdded",
+    defaultMessage: "{numFiles, plural, one {1 file added} other {# files added}}",
+  }, { numFiles: numFiles }),
+  getFileCount: (fileListLength, maxFiles) => intl.formatMessage({
+    id: "uploader.fileCount",
+    defaultMessage: "{x} of {y} Files",
+    description: "A count of the number of files currently uploaded",
+  }, { x: fileListLength, y: maxFiles }),
+  getFileTooLarge: (maxSize) => intl.formatMessage({
+    id: "uploader.fileTooLarge",
+    defaultMessage: "The selected file is too large. Maximum file size is {size}Mb",
+  }, { size: maxSize }),
+  getFilesUploading: (numFilesUploading) => intl.formatMessage({
+    id: "uploader.filesUploading",
+    defaultMessage: "{num, plural, one {1 file uploading} other {# files uploading}}",
+  }, { num: numFilesUploading }),
+  getInvalidFileType: (validTypes) => intl.formatMessage({
+    id: "uploader.invalidFileType",
+    defaultMessage: "The file type is invalid. Accepted types: {validTypes}",
+  }, { validTypes }),
+  getMaxSize: (maxSize) => intl.formatMessage({
+    id: "uploader.maxSize",
+    defaultMessage: "Maximum file size {maxSize}MB",
+    description: "An indicator of the maximum file size the uploader allows",
+  }, {
+    maxSize: maxSize,
+  }),
+  getUploadProgress: (percentage) => intl.formatMessage({
+    id: "uploader.uploadProgress",
+    defaultMessage: "Upload progress: {percentage}%",
+  }, { percentage: percentage }),
 };
 
 export { globalMessages as g, uploaderMessages as u };

package/dist/esm/loader.js

@@ -1,6 +1,6 @@
 import { p as promiseResolve, b as bootstrapLazy } from './index-e887b1ce.js';
 export { s as setNonce } from './index-e887b1ce.js';
-import './global-7ee0d78d.js';
+import './global-2c7bbfe6.js';
 
 /*
  Stencil Client Patch Esm v3.2.0 | MIT Licensed | https://stenciljs.com