@watermarkinsights/ripple 5.12.0 → 5.13.0-alpha.2

package/dist/collection/global/functions.spec.js

@@ -1,126 +0,0 @@
-import { csvToArray, getAcceptedMimeTypesList, intl, snakeCaseToCamelCase, getNewIndexToFocus, transposeMatrix, wrapAround, skipByInterval, getSmallestSkipInterval, calcPercentageInRange, } from "./functions";
-describe("Global functions", () => {
-    it("converts the list of extensions into a list of MIME types", () => {
-        expect(getAcceptedMimeTypesList(["pdf", "doc", "txt"])).toMatchObject([
-            "application/pdf",
-            "application/msword",
-            "text/plain",
-        ]);
-    });
-    it("translates", () => {
-        expect(intl.formatMessage({ id: "date.Monday", defaultMessage: "Monday" })).toEqual("Monday"); // falls back to English when language attribute is not set
-    });
-    it("changes string from snake_case to camelCase", async () => {
-        expect(snakeCaseToCamelCase("snake_case")).toBe("snakeCase");
-        expect(snakeCaseToCamelCase("even_more_words")).toBe("evenMoreWords");
-        expect(snakeCaseToCamelCase("camelCase")).toBe("camelCase");
-        expect(snakeCaseToCamelCase("A regular sentence")).toBe("A regular sentence");
-        expect(snakeCaseToCamelCase("singleword")).toBe("singleword");
-    });
-    it("parses comma separated values properly", async () => {
-        expect(csvToArray("one, two, three")).toStrictEqual(["one", "two", "three"]);
-        expect(csvToArray("four,five, six")).toStrictEqual(["four", "five", "six"]);
-        expect(csvToArray("seven eight,nine ten eleven")).toStrictEqual(["seven eight", "nine ten eleven"]);
-    });
-    it("gets new index to focus correctly", async () => {
-        let index = 1;
-        let direction = "ArrowDown";
-        let listLength = 5;
-        // moves forward
-        expect(getNewIndexToFocus(index, direction, listLength)).toBe(index + 1);
-        // wraps backwards
-        index = 4;
-        expect(getNewIndexToFocus(index, direction, listLength)).toBe(0);
-        // moves backwards
-        direction = "ArrowUp";
-        index = 2;
-        expect(getNewIndexToFocus(index, direction, listLength)).toBe(index - 1);
-        // wraps forward
-        index = 0;
-        expect(getNewIndexToFocus(index, direction, listLength)).toBe(listLength - 1);
-    });
-    it("transposes matrices correctly", () => {
-        expect(transposeMatrix([
-            [0, 1, 2],
-            [3, 4, 5],
-            [6, 7, 8],
-        ])).toStrictEqual([
-            [0, 3, 6],
-            [1, 4, 7],
-            [2, 5, 8],
-        ]);
-        expect(transposeMatrix([
-            [0, 1, 2, 3],
-            [4, 5, 6, 7],
-            [8, 9, 10, 11],
-        ])).toStrictEqual([
-            [0, 4, 8],
-            [1, 5, 9],
-            [2, 6, 10],
-            [3, 7, 11],
-        ]);
-        expect(transposeMatrix([
-            ["0", "1", "2"],
-            ["3", "4", "5"],
-            ["6", "7", "8"],
-        ])).toStrictEqual([
-            ["0", "3", "6"],
-            ["1", "4", "7"],
-            ["2", "5", "8"],
-        ]);
-        expect(transposeMatrix([
-            [0, "1", 2],
-            [3, 4, [5]],
-            [{ key: "value" }, 7, 8],
-        ])).toStrictEqual([
-            [0, 3, { key: "value" }],
-            ["1", 4, 7],
-            [2, [5], 8],
-        ]);
-    });
-    it("wraps around indices correctly", () => {
-        // forward steps
-        expect(wrapAround(0, 1, 8)).toBe(1);
-        expect(wrapAround(2, 3, 8)).toBe(5);
-        expect(wrapAround(7, 1, 8)).toBe(8);
-        // forward to 0
-        expect(wrapAround(8, 1, 8)).toBe(0);
-        expect(wrapAround(2, 7, 8)).toBe(0);
-        // forward beyond 0
-        expect(wrapAround(8, 4, 8)).toBe(3);
-        expect(wrapAround(2, 10, 8)).toBe(3);
-        // backward steps
-        expect(wrapAround(8, -1, 8)).toBe(7);
-        expect(wrapAround(5, -3, 8)).toBe(2);
-        expect(wrapAround(1, -1, 8)).toBe(0);
-        // backward to end
-        expect(wrapAround(0, -1, 8)).toBe(8);
-        expect(wrapAround(7, -8, 8)).toBe(8);
-        // backward beyond end
-        expect(wrapAround(0, -7, 8)).toBe(2);
-        expect(wrapAround(2, -7, 8)).toBe(4);
-        // multiple wraps
-        expect(wrapAround(0, 10, 2)).toBe(1);
-        expect(wrapAround(0, -10, 2)).toBe(2);
-    });
-    it("skips by interval correctly", () => {
-        const list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        expect(skipByInterval(list, 0)).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        expect(skipByInterval(list, 1)).toStrictEqual([0, 2, 4, 6, 8]);
-        expect(skipByInterval(list, 2)).toStrictEqual([0, 3, 6, 9]);
-        expect(skipByInterval(list, 3)).toStrictEqual([0, 4, 8]);
-        expect(skipByInterval(list, 4)).toStrictEqual([0, 5]);
-        expect(skipByInterval(list, 5)).toStrictEqual([0, 6]);
-        expect(skipByInterval(list, 20)).toStrictEqual([0]);
-        expect(getSmallestSkipInterval(list, 6)).toStrictEqual({ skipInterval: 1, skippedList: [0, 2, 4, 6, 8] });
-        expect(getSmallestSkipInterval(list, 5)).toStrictEqual({ skipInterval: 1, skippedList: [0, 2, 4, 6, 8] });
-        expect(getSmallestSkipInterval(list, 3)).toStrictEqual({ skipInterval: 3, skippedList: [0, 4, 8] });
-        expect(getSmallestSkipInterval(list, 1)).toStrictEqual({ skipInterval: 9, skippedList: [0] });
-    });
-    it("calcs percentage in range properly", () => {
-        expect(calcPercentageInRange(13, 0, 100)).toBe(13);
-        expect(calcPercentageInRange(-75, -100, 0)).toBe(25);
-        expect(calcPercentageInRange(50, 25, 75)).toBe(50);
-        expect(calcPercentageInRange(150, 100, 300)).toBe(25);
-    });
-});

package/dist/collection/global/global.js

@@ -1,88 +0,0 @@
-import { setMode } from "@stencil/core";
-import { version } from "../../package.json";
-// 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);
-// MODES (FOR PRODUCT-SPECIFIC STYLING)
-//Checks for mode attribute explicitly set on the document. If "mode" is set on component, it will override the global mode. Falls back to default (Planning styles)
-setMode((elm) => {
-    return elm.getAttribute("mode") || document.documentElement.getAttribute("mode") || "planning";
-});
-// 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;
-}
-`;
-document.head.appendChild(tooltipStyles);
-tooltipContainer.appendChild(tooltipEl);
-document.querySelector("body").appendChild(tooltipContainer);

package/dist/collection/global/interfaces.js

@@ -1,51 +0,0 @@
-//List of icon codes with more indicative descriptors to create labels for icon-only buttons
-export const iconLabels = {
-    f156: "Close",
-    f3eb: "Edit",
-    f739: "Cancel",
-    f12c: "Save",
-    f1c0: "Delete",
-    f349: "Search",
-    f207: "Export info",
-    f1d9: "Open dropdown",
-    f04d: "Go back",
-    f054: "Go forward",
-    f141: "Left",
-    f142: "Right",
-    f35e: "Menu left",
-    f35d: "Toggle menu down",
-    f30d: "Backspace",
-    f645: "Sort hierarchically",
-    f4bb: "Sort alphabetically",
-};
-export 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",
-};
-export const defaultMode = "planning";
-export const getWmMode = (ref) => {
-    return (ref.getAttribute("mode") ||
-        document.documentElement.getAttribute("mode") ||
-        defaultMode);
-};

package/dist/collection/global/intl.js

@@ -1,274 +0,0 @@
-import { intl } from "./functions";
-export 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 }),
-};
-export 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 }),
-};
-export 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",
-    }),
-};
-export 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,
-    }),
-};
-export 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 }),
-};

package/dist/collection/global/services/__mocks__/http-service.js

@@ -1,130 +0,0 @@
-const state = [
-    {
-        uuid: "d57a8104-a07e-4e58-97f6-705d55b15845",
-        uploader_member_uuid: "fd947ce1-ca75-4b88-ba47-4576104cf845",
-        updated_at: "2018-04-16T10:31:48.740000Z",
-        organization_uuid: "d57a8104-a07e-4e58-97f6-705d55b15845",
-        mime_type: "application/pdf",
-        institution_uuid: "c1dac227-b71c-44ae-a4be-eb20929c6e99",
-        inserted_at: "2018-09-17T09:33:45.550000Z",
-        file_path: "bogusurl.dev",
-        file_name: "test.pdf",
-        course_uuid: null,
-    },
-    {
-        uuid: "410ee9ed-af53-4f52-90b1-bf3f054ad86b",
-        uploader_member_uuid: "fd947ce1-ca75-4b88-ba47-4576104cf845",
-        updated_at: "2019-11-26T20:39:38.990000Z",
-        organization_uuid: "8d242cdf-4261-4003-9a91-45575eb7d44e",
-        mime_type: "application/pdf",
-        institution_uuid: "c1dac227-b71c-44ae-a4be-eb20929c6e99",
-        inserted_at: "2019-11-26T20:39:38.990000Z",
-        file_path: "anotherbogusurl.dev",
-        file_name: "brochure.pdf",
-        course_uuid: null,
-    },
-];
-const firstUploadResponseText = {
-    url: "aws-path.url",
-    updated_at: "2019-07-03T14:11:08.000Z",
-    path: "",
-    guid: "12345",
-};
-const secondUploadResponseText = {
-    url: "aws-path.url",
-    updated_at: "2019-07-02T10:14:29.000Z",
-    path: "",
-    guid: "67890",
-};
-const navigatorResponse = {
-    connection_name: "watermarkinsights-idp-qa",
-    current_product_id: "dm",
-    email: "user@email.net",
-    logout_url: "localhost:3333/logout",
-    products: [
-        {
-            description: "Some Aqua description",
-            iconUrl: "https://cdn.watermarkinsights.com/images/login/aqua.svg",
-            id: "aqua",
-            linkUrl: "https://aqua.taskstream.com/sso/login",
-            name: "Aqua",
-        },
-        {
-            description: "Some Digital Measures description",
-            iconUrl: "https://cdn.watermarkinsights.com/images/login/digitalmeasures.svg",
-            id: "dm",
-            linkUrl: "https://www.digitalmeasures.com/login/sso/authenticate",
-            name: "Digital Measures",
-        },
-        {
-            description: "Some Planning description",
-            iconUrl: "https://cdn.watermarkinsights.com/images/login/planningselfstudy.svg",
-            id: "planning",
-            linkUrl: "https://planning.watermarkinsights.com/login/sso",
-            name: "Planning",
-        },
-        {
-            description: "Checking that the component handles anything throwed at it",
-            iconUrl: "https://cdn.watermarkinsights.com/images/login/livetext.svg",
-            id: "something_bonkers",
-            linkUrl: "https://planning.watermarkinsights.com/login/sso",
-            name: "Bonkers",
-        },
-        {
-            description: "c1 = livetext",
-            iconUrl: "https://cdn.watermarkinsights.com/images/login/livetext.svg",
-            id: "c1",
-            linkUrl: "https://livetext.fakeurl/login/sso",
-            name: "Livetext",
-        },
-        {
-            description: "something with an id containing admin",
-            iconUrl: "not.important",
-            id: "banana_admin_shoe",
-            linkUrl: "irrelevant",
-            name: "Platform Admin",
-        },
-    ],
-};
-const responses = {
-    "get-path.url": state,
-    "request-upload-path.url0": firstUploadResponseText,
-    "request-upload-path.url1": secondUploadResponseText,
-    "/platform/navigator/userinfo": navigatorResponse,
-};
-export const getRequest = async (url) => {
-    return Promise.resolve(responses[url]);
-};
-export const postRequest = async (url, payload) => {
-    switch (url) {
-        case "upload-path.url":
-            state.push({
-                uuid: payload.document_uuid,
-                uploader_member_uuid: "fd947ce1-ca75-4b88-ba47-4576104cf845",
-                updated_at: "2019-12-10T20:48:10.138Z",
-                organization_uuid: payload.organization_uuid,
-                mime_type: payload.mime_type,
-                institution_uuid: "c1dac227-b71c-44ae-a4be-eb20929c6e99",
-                inserted_at: "2019-12-10T20:48:10.138Z",
-                file_path: payload.file_path,
-                file_name: payload.file_name,
-                course_uuid: null,
-            });
-            return Promise.resolve();
-        case "request-download-path.url":
-            return Promise.resolve({ url: "aws-download-path.url" });
-    }
-};
-export const deleteRequest = async (url) => {
-    const uuid = url.split("/").pop();
-    // console.log("uuid: ", uuid);
-    const index = state.findIndex((i) => i.uuid === uuid);
-    // console.log("index: ", index);
-    state.splice(index, 1);
-    // console.log("state from DELETE: ", state, Date.now());
-    // return new Promise(resolve => setTimeout(() => resolve(), 300));
-    return Promise.resolve();
-};
-export const putRequest = (_url, _file) => {
-    return Promise.resolve();
-};