@watermarkinsights/ripple 5.13.0-alpha.3 → 5.13.0-alpha.4

package/dist/collection/lang/piglatin.js

@@ -1,101 +0,0 @@
-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/components/interfaces.js

@@ -1,34 +0,0 @@
-//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/components/intl.js

@@ -1,277 +0,0 @@
-import { i as intl } from './functions.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.",
-    }),
-    hide: intl.formatMessage({
-        id: "global.hideVerb",
-        defaultMessage: "Hide",
-        description: "For a button, to hide something",
-    }),
-    locked: intl.formatMessage({
-        id: "global.locked",
-        defaultMessage: "locked",
-        description: "For an interactive element, indicating its state cannot be changed",
-    }),
-    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",
-    }),
-    show: intl.formatMessage({
-        id: "global.showVerb",
-        defaultMessage: "Show",
-        description: "For a button, to show something",
-    }),
-    // -------------------------------------------------------------------------- //
-    //                             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",
-    }),
-    dropInstructions: intl.formatMessage({
-        id: "uploader.dropInstructions",
-        defaultMessage: "Browse or Drag Files Here",
-        description: "Instructions for how to choose files to upload",
-    }),
-    dropFile: intl.formatMessage({
-        id: "uploader.dropFile",
-        defaultMessage: "Drop to Upload",
-        description: "Prompt for use to drop the file they're currently dragging",
-    }),
-    fileRequirements: intl.formatMessage({
-        id: "uploader.fileRequirements",
-        defaultMessage: "File Requirements",
-        description: "Expandable button revealing the uploader's file requirements",
-    }),
-    // -------------------------------------------------------------------------- //
-    //                             Functions                                      //
-    // -------------------------------------------------------------------------- //
-    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}",
-    }, { 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 }),
-    getUploadProgress: (percentage) => intl.formatMessage({
-        id: "uploader.uploadProgress",
-        defaultMessage: "Upload progress: {percentage}%",
-    }, { percentage: percentage }),
-};
-const chartMessages = {
-    interactiveChart: intl.formatMessage({
-        id: "chart.interactiveChart",
-        defaultMessage: "Interactive chart",
-        description: "For screen readers only, a description clarifying the role of the chart widget",
-    }),
-};
-const lineChartMessages = {
-    instructions: intl.formatMessage({
-        id: "linechart.instructions",
-        defaultMessage: "Use Tab and arrow keys to browse elements.",
-        description: "For screen readers only, instructions on how to interact with the line chart component",
-    }),
-    noData: intl.formatMessage({
-        id: "linechart.noData",
-        defaultMessage: "No Data",
-        description: "Message displayed when a data point has missing data",
-    }),
-    highlightQualifier: intl.formatMessage({
-        id: "linechart.highlightQualifier",
-        defaultMessage: "highlighted",
-        description: "Descriptor for highlighted areas of a chart",
-    }),
-    // -------------------------------------------------------------------------- //
-    //                             Functions                                      //
-    // -------------------------------------------------------------------------- //
-    getChangeSince: (prevXValue) => intl.formatMessage({
-        id: "linechart.changeSince",
-        defaultMessage: "Change since {time}",
-        description: "Indicates a comparison between current and previous data",
-    }, {
-        time: prevXValue,
-    }),
-    getToggleButtonLabel: (itemCount) => intl.formatMessage({
-        id: "linechart.toggleButtonLabel",
-        defaultMessage: "Toggle line visibility, list with {itemCount} items",
-    }, {
-        itemCount: itemCount,
-    }),
-    getToggleButtonState: (isPressed) => intl.formatMessage({
-        id: "linechart.toggleButtonState",
-        defaultMessage: "toggle {isPressed, select, true {pressed} other {}}",
-        description: "Descriptor and state for a toggle button UI element",
-    }, {
-        isPressed: isPressed,
-    }),
-    getLineFocusAnnouncement: (label, lineNumber, lineTotal, lineLength) => intl.formatMessage({
-        id: "linechart.getLineFocusAnnouncement",
-        defaultMessage: `{label}, line {lineNumber} of {lineTotal} with {lineLength} data points`,
-    }, {
-        label: label,
-        lineNumber: lineNumber,
-        lineTotal: lineTotal,
-        lineLength: lineLength,
-    }),
-};
-const selectMessages = {
-    multiPlaceholder: intl.formatMessage({
-        id: "select.multiPlaceholder",
-        defaultMessage: "Make a selection",
-    }),
-    singlePlaceholder: intl.formatMessage({
-        id: "select.singlePlaceholder",
-        defaultMessage: "Select an Option",
-    }),
-    multiClearSelection: intl.formatMessage({
-        id: "select.multiClearSelection",
-        defaultMessage: "Clear all Selections",
-        description: "Clear as in remove. Use imperative",
-    }),
-    singleClearSelection: intl.formatMessage({
-        id: "select.singleClearSelection",
-        defaultMessage: "Clear Selection",
-        description: "Clear as in remove. Use imperative",
-    }),
-    selectionCleared: intl.formatMessage({
-        id: "select.selectionCleared",
-        defaultMessage: "Selection cleared",
-    }),
-    searchPlaceholder: intl.formatMessage({
-        id: "select.searchPlaceholder",
-        defaultMessage: "Search",
-        description: "Appears in a search field UI element",
-    }),
-    allSelected: intl.formatMessage({
-        id: "select.allSelected",
-        defaultMessage: "All selected",
-        description: "Indicates all possible options have been selected",
-    }),
-    selectAllMessage: intl.formatMessage({
-        id: "select.selectAll",
-        defaultMessage: "Select All",
-    }),
-    deselectAllMessage: intl.formatMessage({
-        id: "select.deselectAll",
-        defaultMessage: "Deselect All",
-    }),
-    allOptionsSelectedMessage: intl.formatMessage({
-        id: "select.allOptionsSelected",
-        defaultMessage: "All options selected",
-    }),
-    allOptionsDeselectedMessage: intl.formatMessage({
-        id: "select.allOptionsDeselected",
-        defaultMessage: "All options deselected",
-    }),
-    noSearchResults: intl.formatMessage({
-        id: "select.noSearchResults",
-        defaultMessage: "No results found. Please try your search again.",
-    }),
-    optgroupSingleSelectionCount: () => intl.formatMessage({
-        id: "select.optgroupSingleSelectionCount",
-        defaultMessage: "Item Selected",
-        description: "Item refers to an option in a list",
-    }),
-    // -------------------------------------------------------------------------- //
-    //                             Functions                                      //
-    // -------------------------------------------------------------------------- //
-    getOptgroupMultipleSelectionCount: (selectionCount) => intl.formatMessage({
-        id: "select.optgroupMultipleSelectionCount",
-        defaultMessage: "{numberSelected} selected",
-    }, { numberSelected: selectionCount }),
-    getSearchResultsFound: (numResults) => intl.formatMessage({
-        id: "select.searchResultsFound",
-        defaultMessage: "{numberResults, plural, one {1 option found} other {# options found}}",
-    }, { numberResults: numResults }),
-};
-
-export { chartMessages as c, globalMessages as g, lineChartMessages as l, selectMessages as s, uploaderMessages as u };

package/dist/components/priv-calendar.js

@@ -1,6 +0,0 @@
-import { P as PrivCalendar$1, d as defineCustomElement$1 } from './priv-calendar2.js';
-
-const PrivCalendar = PrivCalendar$1;
-const defineCustomElement = defineCustomElement$1;
-
-export { PrivCalendar, defineCustomElement };