@esri/calcite-components 1.0.0-next.591 → 1.0.0-next.593

package/dist/collection/components/tip/tip.e2e.js

@@ -1,42 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { accessible, hidden, renders, defaults, slots } from "../../tests/commonTests";
-import { CSS, SLOTS } from "./resources";
-describe("calcite-tip", () => {
-    it("renders", async () => renders("calcite-tip", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-tip"));
-    it("has property defaults", async () => defaults("calcite-tip", [
-        {
-            propertyName: "headingLevel",
-            defaultValue: undefined
-        }
-    ]));
-    it("is accessible", async () => accessible(`<calcite-tip heading="sample"><p>not dismissible</p></calcite-tip>`));
-    it("has slots", () => slots("calcite-tip", SLOTS));
-    it("should remove the closeButton if nonDismissible prop is true", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tip non-dismissible><p>not dismissible</p></calcite-tip>`);
-        const closeButton = await page.find(`calcite-tip >>> .${CSS.close}`);
-        expect(closeButton).toBeNull();
-    });
-    it("should be hidden after the close button is clicked", async () => {
-        const page = await newE2EPage({ html: `<calcite-tip><p>testing close button</p></calcite-tip>` });
-        const eventSpy = await page.spyOnEvent("calciteTipDismiss", "window");
-        const closeButton = await page.find(`calcite-tip >>> .${CSS.close}`);
-        await closeButton.click();
-        const tip = await page.find(`calcite-tip`);
-        const isVisible = await tip.isVisible();
-        expect(isVisible).toBe(false);
-        expect(eventSpy).toHaveReceivedEvent();
-    });
-    it("header should only be visible if has a heading", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tip><p>testing</p></calcite-tip>`);
-        let header = await page.find(`calcite-tip >>> .${CSS.header}`);
-        expect(header).toBeNull();
-        const tip = await page.find("calcite-tip");
-        tip.setProperty("heading", "test");
-        await page.waitForChanges();
-        header = await page.find(`calcite-tip >>> .${CSS.header}`);
-        expect(header).not.toBeNull();
-    });
-});

package/dist/collection/components/tip-group/tip-group.e2e.js

@@ -1,6 +0,0 @@
-import { accessible, hidden, renders } from "../../tests/commonTests";
-describe("calcite-tip-group", () => {
-    it("renders", async () => renders("calcite-tip-group", { display: "block" }));
-    it("honors hidden attribute", async () => hidden("calcite-tip-group"));
-    it("is accessible", async () => accessible(`calcite-tip-group`));
-});

package/dist/collection/components/tip-manager/tip-manager.e2e.js

@@ -1,176 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { CSS, TEXT } from "./resources";
-import { accessible, defaults, renders, hidden } from "../../tests/commonTests";
-describe("calcite-tip-manager", () => {
-    it("renders", async () => renders("calcite-tip-manager", { display: "block" }));
-    it("honors hidden attribute", async () => hidden("calcite-tip-manager"));
-    describe("first render", () => {
-        it("should render and show the default title", async () => {
-            const page = await newE2EPage();
-            await page.setContent(`<calcite-tip-manager><calcite-tip><p>basic render</p></calcite-tip></calcite-tip-manager>`);
-            const tipManager = await page.find("calcite-tip-manager");
-            expect(tipManager).not.toBeNull();
-            const isVisible = await tipManager.isVisible();
-            expect(isVisible).toBe(true);
-            const title = await page.find(`calcite-tip-manager >>> .${CSS.heading}`);
-            expect(title.innerText).toBe(TEXT.defaultGroupTitle);
-        });
-        it("has property defaults", async () => defaults("calcite-tip-manager", [
-            {
-                propertyName: "headingLevel",
-                defaultValue: undefined
-            }
-        ]));
-        it("is accessible", async () => accessible(`<calcite-tip-manager><calcite-tip heading="sample"><p>basic render</p></calcite-tip></calcite-tip-manager>`));
-        it("should pre-select the correct tip if the selected attribute is set", async () => {
-            const page = await newE2EPage();
-            await page.setContent(`<calcite-tip-manager>
-          <calcite-tip id="one"><p>no pre-selected attribute</p></calcite-tip>
-          <calcite-tip id="two" selected><p>pre-selected and not first</p></calcite-tip>
-        </calcite-tip-manager>`);
-            await page.waitForChanges();
-            const tipManager = await page.find("calcite-tip-manager");
-            const selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual("two");
-        });
-    });
-    describe("close button", () => {
-        it("should be hidden after the close button is clicked", async () => {
-            const page = await newE2EPage({
-                html: `<calcite-tip-manager><calcite-tip><p>Close behavior</p></calcite-tip></calcite-tip-manager>`
-            });
-            const tipManager = await page.find("calcite-tip-manager");
-            let container = await page.find(`calcite-tip-manager >>> .${CSS.container}`);
-            let isVisible = await container.isVisible();
-            expect(isVisible).toBe(true);
-            const toggleEventSpy = await page.spyOnEvent("calciteTipManagerToggle", "window");
-            const closeEventSpy = await page.spyOnEvent("calciteTipManagerClose", "window");
-            const closeButton = await page.find(`calcite-tip-manager >>> .${CSS.close}`);
-            await closeButton.click();
-            await page.waitForChanges();
-            container = await page.find(`calcite-tip-manager >>> .${CSS.container}`);
-            isVisible = await container.isVisible();
-            expect(isVisible).toBe(false);
-            expect(toggleEventSpy).toHaveReceivedEvent();
-            expect(closeEventSpy).toHaveReceivedEvent();
-            const isClosed = await tipManager.getProperty("closed");
-            expect(isClosed).toBe(true);
-        });
-    });
-    describe("pagination", () => {
-        it("should select the first tip by default and change the selectedIndex when the previous or next buttons are clicked", async () => {
-            const page = await newE2EPage({
-                html: `<calcite-tip-manager>
-      <calcite-tip id="one"><p>first tip default selected</p></calcite-tip>
-      <calcite-tip id="two"><p>next/prev behavior</p></calcite-tip>
-    </calcite-tip-manager>`
-            });
-            await page.waitForChanges();
-            const tipManager = await page.find("calcite-tip-manager");
-            let selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual("one"); // default selected tip is index 0
-            let paginationText = await page.find(`calcite-tip-manager >>> .${CSS.pagePosition}`);
-            expect(paginationText.textContent).toEqual(`${TEXT.defaultPaginationLabel} 1/2`);
-            const nextButton = await page.find(`calcite-tip-manager >>> .${CSS.pageNext}`);
-            await nextButton.click();
-            await page.waitForChanges();
-            selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual("two");
-            paginationText = await page.find(`calcite-tip-manager >>> .${CSS.pagePosition}`);
-            expect(paginationText.textContent).toEqual(`${TEXT.defaultPaginationLabel} 2/2`);
-            const previousButton = await page.find(`calcite-tip-manager >>> .${CSS.pagePrevious}`);
-            await previousButton.click();
-            await page.waitForChanges();
-            selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual("one");
-            paginationText = await page.find(`calcite-tip-manager >>> .${CSS.pagePosition}`);
-            expect(paginationText.textContent).toEqual(`${TEXT.defaultPaginationLabel} 1/2`);
-        });
-        //Ø TODO: split the group-title test into one for first render, and another for pagination
-        it("should update the group title to match the selected tips attribute", async () => {
-            const sharedTitle = "group1";
-            const title2 = "group2";
-            const page = await newE2EPage({
-                html: `<calcite-tip-manager>
-      <calcite-tip-group group-title=${sharedTitle}>
-        <calcite-tip><p>group title behavior</p></calcite-tip>
-        <calcite-tip><p>same title as first one</p></calcite-tip>
-      </calcite-tip-group>
-      <calcite-tip-group group-title=${title2}>
-        <calcite-tip ><p>different title</p></calcite-tip>
-      </calcite-tip-group>
-      <calcite-tip><p>default title</p></calcite-tip>
-    </calcite-tip-manager>`
-            });
-            await page.waitForChanges();
-            const title = await page.find(`calcite-tip-manager >>> .${CSS.heading}`);
-            expect(title.innerText).toBe(sharedTitle);
-            const nextButton = await page.find(`calcite-tip-manager >>> .${CSS.pageNext}`);
-            await nextButton.click();
-            const sharedtitleNode = await page.find(`calcite-tip-manager >>> .${CSS.heading}`);
-            expect(sharedtitleNode.innerText).toBe(sharedTitle);
-            await nextButton.click();
-            const title2Node = await page.find(`calcite-tip-manager >>> .${CSS.heading}`);
-            expect(title2Node.innerText).toBe(title2);
-            await nextButton.click();
-            const defaultTitleNode = await page.find(`calcite-tip-manager >>> .${CSS.heading}`);
-            expect(defaultTitleNode.innerText).toBe(TEXT.defaultGroupTitle);
-        });
-        it("pagination should be hidden if there is 1 or fewer tips", async () => {
-            const page = await newE2EPage();
-            await page.setContent(`<calcite-tip-manager><calcite-tip><p>basic render</p></calcite-tip></calcite-tip-manager>`);
-            const pagination = await page.find(`calcite-tip-manager >>> .${CSS.pagination}`);
-            expect(pagination).toBeNull();
-        });
-    });
-    describe("handling dom updates after initial render", () => {
-        it("should update if tips are added after intial load", async () => {
-            const page = await newE2EPage({
-                html: `<calcite-tip-manager>
-      <calcite-tip><p>dynamically adding/removing tips</p></calcite-tip>
-    </calcite-tip-manager>`
-            });
-            const tipManager = await page.find("calcite-tip-manager");
-            const newTipId = "newTip";
-            await page.evaluate((newId) => {
-                const mgr = document.querySelector("calcite-tip-manager");
-                const newTip = mgr.querySelector("calcite-tip:last-child").cloneNode(true);
-                newTip.id = newId;
-                mgr.appendChild(newTip);
-            }, newTipId);
-            await page.waitForChanges();
-            const tips = await page.findAll("calcite-tip-manager calcite-tip");
-            expect(tips.length).toBe(2);
-            const nextButton = await page.find(`calcite-tip-manager >>> .${CSS.pageNext}`);
-            await nextButton.click();
-            await page.waitForChanges();
-            const selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual(newTipId);
-        });
-        it("should update visible tip if active tip is removed", async () => {
-            const page = await newE2EPage();
-            await page.setContent(`<calcite-tip-manager>
-          <calcite-tip id="one"><p>dynamically adding/removing tips</p></calcite-tip>
-          <calcite-tip id="two"><p>dynamically adding/removing tips</p></calcite-tip>
-        </calcite-tip-manager>`);
-            const tipManager = await page.find("calcite-tip-manager");
-            await page.evaluate(() => {
-                document.querySelector("calcite-tip:first-child").remove();
-            });
-            await page.waitForChanges();
-            const selectedTip = await tipManager.find(`calcite-tip[selected]`);
-            expect(selectedTip.id).toEqual("two");
-        });
-    });
-    it("should set headingLevel of tip", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tip-manager heading-level="1">
-        <calcite-tip id="one" heading="test"><p>no pre-selected attribute</p></calcite-tip>
-      </calcite-tip-manager>`);
-        await page.waitForChanges();
-        const tipManager = await page.find("calcite-tip-manager");
-        expect(await tipManager.getProperty("headingLevel")).toEqual(1);
-        const heading = await page.find(`calcite-tip >>> .${CSS.heading}`);
-        expect(heading.tagName).toEqual("H2");
-    });
-});

package/dist/collection/components/tip-manager/tip-manager.spec.js

@@ -1,13 +0,0 @@
-// TODO: Uncomment this test when there's a resolution to this bug. https://github.com/ionic-team/stencil/issues/1669
-// import { TipManager } from "./calcite-tip-manager";
-describe.skip("TipManager", () => {
-    it("should increment/decrement the selectedIndex when the public next/prev methods are called", () => {
-        // const tipManager = new TipManager();
-        // tipManager.total = 2; //needed to
-        // expect(tipManager.selectedIndex).toBe(0);
-        // tipManager.nextTip();
-        // expect(tipManager.selectedIndex).toBe(1);
-        // tipManager.previousTip();
-        // expect(tipManager.selectedIndex).toBe(0);
-    });
-});

package/dist/collection/components/tooltip/tooltip.e2e.js

@@ -1,359 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { TOOLTIP_DELAY_MS } from "../tooltip/resources";
-import { accessible, defaults, hidden, floatingUIOwner, renders } from "../../tests/commonTests";
-import { html } from "../../../support/formatting";
-describe("calcite-tooltip", () => {
-    it("renders", async () => {
-        await renders(`calcite-tooltip`, { visible: false, display: "block" });
-        await renders(`<calcite-tooltip open reference-element="ref"></calcite-tooltip><div id="ref">😄</div>`, {
-            display: "block"
-        });
-    });
-    it("is accessible when closed", async () => accessible(`<calcite-tooltip label="test" reference-element="ref"></calcite-tooltip><div id="ref">😄</div>`));
-    it("is accessible when open", async () => accessible(`<calcite-tooltip label="test" open reference-element="ref"></calcite-tooltip><div id="ref">😄</div>`));
-    it("honors hidden attribute", async () => hidden(`<calcite-tooltip open></calcite-tooltip >`));
-    it("has property defaults", async () => defaults("calcite-tooltip", [
-        {
-            propertyName: "open",
-            defaultValue: false
-        },
-        {
-            propertyName: "placement",
-            defaultValue: "auto"
-        },
-        {
-            propertyName: "offsetDistance",
-            defaultValue: 6
-        },
-        {
-            propertyName: "offsetSkidding",
-            defaultValue: 0
-        },
-        {
-            propertyName: "referenceElement",
-            defaultValue: undefined
-        },
-        {
-            propertyName: "overlayPositioning",
-            defaultValue: "absolute"
-        }
-    ]));
-    it("should have zIndex of 999", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip reference-element="ref" open>content</calcite-tooltip><div id="ref">referenceElement</div>`);
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        await page.waitForChanges();
-        const style = await tooltip.getComputedStyle();
-        expect(style.zIndex).toBe("999");
-    });
-    it("tooltip positions when referenceElement is set", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip open></calcite-tooltip><div>referenceElement</div>`);
-        const element = await page.find("calcite-tooltip");
-        let computedStyle = await element.getComputedStyle();
-        expect(computedStyle.transform).toBe("matrix(0, 0, 0, 0, 0, 0)");
-        await page.$eval("calcite-tooltip", (elm) => {
-            const referenceElement = document.createElement("div");
-            document.body.appendChild(referenceElement);
-            elm.referenceElement = referenceElement;
-        });
-        await page.waitForChanges();
-        computedStyle = await element.getComputedStyle();
-        expect(computedStyle.transform).not.toBe("matrix(0, 0, 0, 0, 0, 0)");
-    });
-    it("open tooltip should be visible", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip></calcite-tooltip><div>referenceElement</div>`);
-        const element = await page.find("calcite-tooltip");
-        await page.$eval("calcite-tooltip", (elm) => {
-            const referenceElement = document.createElement("div");
-            document.body.appendChild(referenceElement);
-            elm.referenceElement = referenceElement;
-        });
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        expect(await tooltip.isVisible()).toBe(false);
-        element.setProperty("open", true);
-        await page.waitForChanges();
-        expect(await tooltip.isVisible()).toBe(true);
-    });
-    it("should accept referenceElement as string id", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip reference-element="ref" open>content</calcite-tooltip><div id="ref">referenceElement</div>`);
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        await page.waitForChanges();
-        expect(await tooltip.isVisible()).toBe(true);
-        const element = await page.find("calcite-tooltip");
-        const computedStyle = await element.getComputedStyle();
-        expect(computedStyle.transform).not.toBe("matrix(0, 0, 0, 0, 0, 0)");
-    });
-    it("should accept referenceElement as virtual element", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip open>content</calcite-tooltip>`);
-        await page.$eval("calcite-tooltip", (tooltip) => {
-            const virtualElement = {
-                getBoundingClientRect: () => ({
-                    width: 0,
-                    height: 0,
-                    top: 100,
-                    right: 100,
-                    bottom: 100,
-                    left: 600
-                })
-            };
-            tooltip.referenceElement = virtualElement;
-        });
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        expect(await tooltip.isVisible()).toBe(true);
-        const computedStyle = await tooltip.getComputedStyle();
-        expect(computedStyle.transform).not.toBe("matrix(0, 0, 0, 0, 0, 0)");
-    });
-    it("should honor hover interaction", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip reference-element="ref">content</calcite-tooltip><div id="ref">referenceElement</div>`);
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        expect(await tooltip.isVisible()).toBe(false);
-        const ref = await page.find("#ref");
-        await ref.hover();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        expect(await tooltip.isVisible()).toBe(true);
-    });
-    it("should honor hover interaction with span inside", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip reference-element="ref">content</calcite-tooltip><div id="ref"><span>referenceElement<span></div>`);
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        expect(await tooltip.isVisible()).toBe(false);
-        const ref = await page.find("#ref span");
-        await ref.hover();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        expect(await tooltip.isVisible()).toBe(true);
-    });
-    it("should honor text", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip reference-element="ref" open>hi</calcite-tooltip><div id="ref">referenceElement</div>`);
-        await page.waitForChanges();
-        const content = await page.find("calcite-tooltip");
-        expect(await content.isVisible()).toBe(true);
-        expect(content.textContent).toBe("hi");
-    });
-    it("should honor tooltips on pointerover/pointerout", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <button id="test">test</button>
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.hover();
-        await page.waitForChanges();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        expect(await tooltip.getProperty("open")).toBe(true);
-        const testElement = await page.find("#test");
-        await testElement.hover();
-        await page.waitForChanges();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should honor tooltips on focus/blur", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <button id="test">test</button>
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.focus();
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        const testElement = await page.find("#test");
-        await testElement.focus();
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should not open tooltip when clicked", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <button id="test">test</button>
-        <calcite-tooltip id="tooltip" reference-element="ref">Content</calcite-tooltip>
-        <div tabindex="0" id="ref">Button</div>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        await page.evaluate(() => {
-            const ref = document.getElementById("ref");
-            ref.click();
-        });
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should honor focused tooltip closing with ESC key", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.focus();
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        await referenceElement.press("Escape");
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should honor hovered tooltip closing with ESC key", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.hover();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should honor hovered and focused tooltip closing with ESC key", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.focus();
-        await referenceElement.hover();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should only open the last focused tooltip", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip id="focusTip" reference-element="focusRef">Content</calcite-tooltip>
-        <button id="focusRef">Button</button>
-        <calcite-tooltip id="hoverTip" reference-element="hoverRef">Content</calcite-tooltip>
-        <button id="hoverRef">Button</button>
-      `);
-        await page.waitForChanges();
-        const focusTip = await page.find("#focusTip");
-        const focusRef = await page.find("#focusRef");
-        const hoverTip = await page.find("#hoverTip");
-        expect(await focusTip.getProperty("open")).toBe(false);
-        expect(await hoverTip.getProperty("open")).toBe(false);
-        await page.$eval("#hoverRef", (elm) => {
-            elm.dispatchEvent(new Event("pointerover"));
-        });
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        await page.waitForChanges();
-        expect(await focusTip.getProperty("open")).toBe(false);
-        expect(await hoverTip.getProperty("open")).toBe(true);
-        await focusRef.focus();
-        await page.waitForChanges();
-        expect(await focusTip.getProperty("open")).toBe(true);
-        expect(await hoverTip.getProperty("open")).toBe(false);
-    });
-    it("owns a floating-ui", () => floatingUIOwner(`<calcite-tooltip reference-element="ref">content</calcite-tooltip><div id="ref">referenceElement</div>`, "open"));
-    it("should only open the last hovered tooltip", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip id="focusTip" reference-element="focusRef">Content</calcite-tooltip>
-        <button id="focusRef">Button</button>
-        <calcite-tooltip id="hoverTip" reference-element="hoverRef">Content</calcite-tooltip>
-        <button id="hoverRef">Button</button>
-      `);
-        await page.waitForChanges();
-        const focusTip = await page.find("#focusTip");
-        const focusRef = await page.find("#focusRef");
-        const hoverTip = await page.find("#hoverTip");
-        expect(await focusTip.getProperty("open")).toBe(false);
-        expect(await hoverTip.getProperty("open")).toBe(false);
-        await focusRef.focus();
-        await page.waitForChanges();
-        expect(await focusTip.getProperty("open")).toBe(true);
-        expect(await hoverTip.getProperty("open")).toBe(false);
-        await page.$eval("#hoverRef", (elm) => {
-            elm.dispatchEvent(new Event("pointerover"));
-        });
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        await page.waitForChanges();
-        expect(await focusTip.getProperty("open")).toBe(false);
-        expect(await hoverTip.getProperty("open")).toBe(true);
-    });
-    it("should close tooltip when closeOnClick is true and referenceElement is clicked", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-      `);
-        await page.waitForChanges();
-        const tooltip = await page.find("calcite-tooltip");
-        expect(await tooltip.getProperty("open")).toBe(false);
-        const referenceElement = await page.find("#ref");
-        await referenceElement.hover();
-        await page.waitForTimeout(TOOLTIP_DELAY_MS);
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        await referenceElement.click();
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(true);
-        tooltip.setProperty("closeOnClick", true);
-        await page.waitForChanges();
-        await referenceElement.click();
-        await page.waitForChanges();
-        expect(await tooltip.getProperty("open")).toBe(false);
-    });
-    it("should still function when disconnected and reconnected", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<button id="test">test</button>
-        <p>Hello World</p>
-        <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-        <button id="ref">Button</button>
-        <p>Hello World 2</p>
-        <div id="transfer"></div>`);
-        await page.waitForChanges();
-        const tooltip = await page.find(`calcite-tooltip`);
-        const ref = await page.find("#ref");
-        expect(await tooltip.isVisible()).toBe(false);
-        await ref.focus();
-        await page.waitForChanges();
-        expect(await tooltip.isVisible()).toBe(true);
-        const testElement = await page.find("#test");
-        await testElement.focus();
-        await page.waitForChanges();
-        expect(await tooltip.isVisible()).toBe(false);
-        await page.$eval("calcite-tooltip", (tooltipEl) => {
-            const transferEl = document.getElementById("transfer");
-            transferEl.appendChild(tooltipEl);
-        });
-        await page.waitForChanges();
-        await ref.focus();
-        await page.waitForChanges();
-        expect(await tooltip.isVisible()).toBe(true);
-    });
-});

package/dist/collection/components/tooltip-manager/tooltip-manager.e2e.js

@@ -1,19 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { accessible, hidden, renders } from "../../tests/commonTests";
-import { html } from "../../../support/formatting";
-describe("calcite-tooltip-manager", () => {
-    it("renders", async () => renders(`<calcite-tooltip-manager></calcite-tooltip-manager>`, { display: "block" }));
-    it("is accessible", async () => accessible(html `<button id="test">test</button>
-        <calcite-tooltip-manager>
-          <calcite-tooltip reference-element="ref">Content</calcite-tooltip>
-          <button id="ref">Button</button>
-        </calcite-tooltip-manager>`));
-    it("honors hidden attribute", async () => hidden("calcite-tooltip-manager"));
-    it("should be positioned relative", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-tooltip-manager></calcite-tooltip-manager>`);
-        await page.waitForChanges();
-        const manager = await page.find("calcite-tooltip-manager");
-        expect((await manager.getComputedStyle()).position).toBe("relative");
-    });
-});