@esri/calcite-components 1.0.0-next.597 → 1.0.0-next.598

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

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

package/dist/collection/components/dropdown-item/dropdown-item.e2e.js

@@ -1,6 +0,0 @@
-import { focusable, renders, hidden } from "../../tests/commonTests";
-describe("calcite-dropdown-item", () => {
-    it("renders", () => renders("calcite-dropdown-item", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-dropdown-item"));
-    it("can be focused", async () => focusable(`calcite-dropdown-item`));
-});

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

@@ -1,114 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { accessible, disabled, hidden, renders } from "../../tests/commonTests";
-import { CSS } from "./resources";
-import { defaults } from "../../tests/commonTests";
-describe("calcite-fab", () => {
-    it("renders", async () => renders("calcite-fab", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-fab"));
-    it("has property defaults", async () => defaults("calcite-fab", [
-        {
-            propertyName: "scale",
-            defaultValue: "m"
-        },
-        {
-            propertyName: "appearance",
-            defaultValue: "outline"
-        }
-    ]));
-    it("can be disabled", () => disabled("calcite-fab"));
-    it(`should set all internal calcite-button types to 'button'`, async () => {
-        const page = await newE2EPage({
-            html: "<calcite-fab></calcite-fab>"
-        });
-        const buttons = await page.findAll("calcite-fab >>> calcite-button");
-        expect(buttons).toHaveLength(1);
-        for (const button of buttons) {
-            expect(await button.getProperty("type")).toBe("button");
-        }
-    });
-    it("should have visible text when text is enabled", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world" text-enabled></calcite-fab>`);
-        const button = await page.find(`calcite-fab >>> .${CSS.button}`);
-        const text = button.textContent;
-        expect(text).toBe("hello world");
-    });
-    it("should not have a tooltip when text-enabled", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world" text-enabled></calcite-fab>`);
-        const button = await page.find(`calcite-fab >>> .${CSS.button}`);
-        expect(button.getAttribute("title")).toBe(null);
-    });
-    it("should have a tooltip when not text-enabled", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world"></calcite-fab>`);
-        const button = await page.find(`calcite-fab >>> .${CSS.button}`);
-        expect(button.getAttribute("title")).toBe("hello world");
-        const fab = await page.find("calcite-fab");
-        fab.setProperty("label", "label");
-        await page.waitForChanges();
-        expect(button.getAttribute("title")).toBe("label");
-    });
-    it("should not have visible text when text is not enabled", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world"></calcite-fab>`);
-        const button = await page.find(`calcite-fab >>> .${CSS.button}`);
-        const text = button.textContent;
-        expect(text).toBe("");
-    });
-    it("should have label", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world" label="hi"></calcite-fab>`);
-        const calciteButton = await page.find(`calcite-fab >>> .${CSS.button}`);
-        expect(calciteButton.getAttribute("title")).toBe("hi");
-        expect(await calciteButton.getProperty("label")).toBe("hi");
-    });
-    it("should have appearance=outline", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab text="hello world"></calcite-fab>`);
-        const fab = await page.find(`calcite-fab >>> .${CSS.button}`);
-        expect(fab.getAttribute("appearance")).toBe("outline");
-    });
-    it("should have appearance=solid", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-fab appearance="solid" text="hello world"></calcite-fab>`);
-        const fab = await page.find(`calcite-fab >>> .${CSS.button}`);
-        expect(fab.getAttribute("appearance")).toBe("solid");
-    });
-    it("should be accessible", async () => {
-        await accessible(`<calcite-fab label="hello world" text="hello world"></calcite-fab>`);
-        await accessible(`<calcite-fab label="hello world" text="hello world" disabled text-enabled></calcite-fab>`);
-    });
-    describe("when invalid appearance values are passed", () => {
-        describe("when value is 'transparent'", () => {
-            it("should render with default 'outline' appearance", async () => {
-                const page = await newE2EPage({
-                    html: `
-          <calcite-fab
-            text="FAB"
-            text-enabled
-            appearance="transparent"
-          ></calcite-fab>
-          `
-                });
-                const fab = await page.find(`calcite-fab >>> .${CSS.button}`);
-                expect(fab.getAttribute("appearance")).toBe("outline");
-            });
-        });
-        describe("when value is 'clear'", () => {
-            it("should render with default 'outline' appearance", async () => {
-                const page = await newE2EPage({
-                    html: `
-          <calcite-fab
-            text="FAB"
-            text-enabled
-            appearance="clear"
-          ></calcite-fab>
-          `
-                });
-                const fab = await page.find(`calcite-fab >>> .${CSS.button}`);
-                expect(fab.getAttribute("appearance")).toBe("outline");
-            });
-        });
-    });
-});

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

@@ -1,205 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { accessible, defaults, disabled, focusable, hidden, reflects, renders } from "../../tests/commonTests";
-import { DEBOUNCE_TIMEOUT } from "./resources";
-import { CSS as INPUT_CSS } from "../input/resources";
-describe("calcite-filter", () => {
-    it("renders", async () => renders("calcite-filter", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-filter"));
-    it("is accessible", async () => accessible("calcite-filter"));
-    it("is focusable", async () => focusable("calcite-filter"));
-    it("can be disabled", () => disabled("calcite-filter"));
-    it("reflects", async () => reflects("calcite-filter", [
-        {
-            propertyName: "disabled",
-            value: true
-        },
-        {
-            propertyName: "scale",
-            value: "s"
-        }
-    ]));
-    it("has defaults", async () => defaults("calcite-filter", [
-        {
-            propertyName: "disabled",
-            defaultValue: false
-        },
-        {
-            propertyName: "filteredItems",
-            defaultValue: []
-        },
-        {
-            propertyName: "scale",
-            defaultValue: "m"
-        }
-    ]));
-    it("sets scale on the input", async () => {
-        const scale = "s";
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-filter scale="${scale}"></calcite-filter>`);
-        const input = await page.find(`calcite-filter >>> calcite-input`);
-        expect(await input.getProperty("scale")).toBe(scale);
-    });
-    describe("strings", () => {
-        it("should update the filter placeholder when a string is provided", async () => {
-            const page = await newE2EPage();
-            const placeholderText = "placeholder";
-            await page.setContent(`<calcite-filter placeholder="${placeholderText}"></calcite-filter>`);
-            const input = await page.find(`calcite-filter >>> calcite-input`);
-            expect(await input.getProperty("placeholder")).toBe(placeholderText);
-        });
-    });
-    describe("clear button", () => {
-        let page;
-        beforeEach(async () => {
-            page = await newE2EPage();
-            await page.setContent("<calcite-filter></calcite-filter>");
-            await page.evaluate(() => {
-                const filter = document.querySelector("calcite-filter");
-                filter.items = [{ foo: "bar" }];
-            });
-        });
-        describe("clearing value", () => {
-            const filterIsFocused = async () => page.evaluate(() => document.querySelector("calcite-filter") === document.activeElement);
-            it("should clear the value in the input when pressed", async () => {
-                const filter = await page.find("calcite-filter");
-                await filter.callMethod("setFocus");
-                await page.keyboard.type("developer");
-                await page.waitForChanges();
-                expect(await filter.getProperty("value")).toBe("developer");
-                await page.$eval("calcite-filter", async (filter, buttonSelector) => {
-                    return filter.shadowRoot
-                        .querySelector("calcite-input")
-                        .shadowRoot.querySelector(buttonSelector)
-                        .click();
-                }, `.${INPUT_CSS.clearButton}`);
-                await page.waitForChanges();
-                expect(await filter.getProperty("value")).toBe("");
-                expect(await filterIsFocused()).toBe(true);
-            });
-            it("should clear the value in the input when the Escape key is pressed", async () => {
-                const filter = await page.find("calcite-filter");
-                await filter.callMethod("setFocus");
-                await page.keyboard.type("developer");
-                await page.waitForChanges();
-                await page.keyboard.press("Escape");
-                await page.waitForChanges();
-                expect(await filter.getProperty("value")).toBe("");
-                expect(await filterIsFocused()).toBe(true);
-            });
-        });
-    });
-    function assertMatchingItems(filtered, values) {
-        expect(filtered).toHaveLength(values.length);
-        values.forEach((value) => expect(filtered.find((element) => element.value === value)).toBeDefined());
-    }
-    describe("filter behavior", () => {
-        let page;
-        beforeEach(async () => {
-            page = await newE2EPage();
-            await page.setContent("<calcite-filter></calcite-filter>");
-            await page.evaluate(() => {
-                const filter = document.querySelector("calcite-filter");
-                filter.items = [
-                    {
-                        name: "Harry",
-                        description: "developer",
-                        value: "harry",
-                        metadata: { haircolor: "red", favoriteBand: "MetallicA" }
-                    },
-                    {
-                        name: "Matt",
-                        description: "developer",
-                        value: "matt",
-                        metadata: { haircolor: "black", favoriteBand: "Radiohead" }
-                    },
-                    {
-                        name: "Franco",
-                        description: "developer",
-                        value: "franco",
-                        metadata: { haircolor: "black", favoriteBand: "The Mars Volta" }
-                    },
-                    {
-                        name: "Katy",
-                        description: "engineer",
-                        value: "katy",
-                        metadata: { haircolor: "red", favoriteBand: "unknown" }
-                    },
-                    {
-                        name: "Jon",
-                        description: "developer",
-                        value: "jon",
-                        metadata: { haircolor: "brown", favoriteBand: "Hippity Hops" }
-                    },
-                    {
-                        name: "regex",
-                        description: "regex",
-                        value: "regex",
-                        metadata: { haircolor: "rainbow", favoriteBand: "regex()" }
-                    }
-                ];
-            });
-        });
-        it("updates filtered items after filtering", async () => {
-            const filterChangeSpy = await page.spyOnEvent("calciteFilterChange");
-            const waitForEvent = page.waitForEvent("calciteFilterChange");
-            const filter = await page.find("calcite-filter");
-            await filter.callMethod("setFocus");
-            await filter.type("developer");
-            await waitForEvent;
-            expect(filterChangeSpy).toHaveReceivedEventTimes(1);
-            assertMatchingItems(await filter.getProperty("filteredItems"), ["harry", "matt", "franco", "jon"]);
-            await page.evaluate(() => {
-                const filter = document.querySelector("calcite-filter");
-                filter.items = filter.items.slice(3);
-            });
-            await page.waitForTimeout(DEBOUNCE_TIMEOUT);
-            assertMatchingItems(await filter.getProperty("filteredItems"), ["jon"]);
-            expect(filterChangeSpy).toHaveReceivedEventTimes(1);
-        });
-        it("searches recursively in items and works and matches on a partial string ignoring case", async () => {
-            const waitForEvent = page.waitForEvent("calciteFilterChange");
-            const filter = await page.find("calcite-filter");
-            await filter.callMethod("setFocus");
-            await filter.type("volt");
-            await waitForEvent;
-            assertMatchingItems(await filter.getProperty("filteredItems"), ["franco"]);
-        });
-        it("should escape regex", async () => {
-            const waitForEvent = page.waitForEvent("calciteFilterChange");
-            const filter = await page.find("calcite-filter");
-            await filter.callMethod("setFocus");
-            await filter.type("regex()");
-            await waitForEvent;
-            assertMatchingItems(await filter.getProperty("filteredItems"), ["regex"]);
-        });
-    });
-    describe("filter behavior with predefined value prop", () => {
-        let page;
-        beforeEach(async () => {
-            page = await newE2EPage();
-            await page.setContent(`<calcite-filter value="harry"></calcite-filter>`);
-            await page.evaluate(() => {
-                const filter = document.querySelector("calcite-filter");
-                filter.items = [
-                    {
-                        name: "Harry",
-                        description: "developer",
-                        value: "harry",
-                        metadata: { haircolor: "red", favoriteBand: "MetallicA" }
-                    },
-                    {
-                        name: "Matt",
-                        description: "developer",
-                        value: "matt",
-                        metadata: { haircolor: "black", favoriteBand: "Radiohead" }
-                    }
-                ];
-            });
-        });
-        it("should return matching value", async () => {
-            const filter = await page.find("calcite-filter");
-            await page.waitForTimeout(DEBOUNCE_TIMEOUT);
-            assertMatchingItems(await filter.getProperty("filteredItems"), ["harry"]);
-        });
-    });
-});

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

@@ -1,166 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { CSS } from "./resources";
-import { CSS as ITEM_CSS } from "../flow-item/resources";
-import { accessible, hidden, renders } from "../../tests/commonTests";
-import { html } from "../../../support/formatting";
-describe("calcite-flow", () => {
-    it("renders", async () => renders("calcite-flow", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-flow"));
-    it("frame defaults", async () => {
-        const page = await newE2EPage();
-        await page.setContent("<calcite-flow></calcite-flow>");
-        const element = await page.find(`calcite-flow >>> .${CSS.frame}`);
-        expect(element).toHaveClass(CSS.frame);
-        expect(element).not.toHaveClass(CSS.frameAdvancing);
-        expect(element).not.toHaveClass(CSS.frameRetreating);
-    });
-    describe("works with flow-items and panels (deprecated)", () => {
-        testItemBehavior("flow-item");
-        testItemBehavior("panel");
-        function testItemBehavior(itemType) {
-            const itemTag = `calcite-${itemType}`;
-            it("back() method should remove item", async () => {
-                const page = await newE2EPage();
-                await page.setContent(`<calcite-flow><${itemTag}></${itemTag}></calcite-flow>`);
-                const flow = await page.find("calcite-flow");
-                await flow.callMethod("back");
-                await page.waitForChanges();
-                const flowItem = await page.find(itemTag);
-                expect(flowItem).toBeNull();
-            });
-            it("goes back when item back button is clicked", async () => {
-                const page = await newE2EPage();
-                await page.setContent(html `<calcite-flow show-back-button>
-          <${itemTag} id="first"></${itemTag}>
-          <${itemTag} id="second"></${itemTag}>
-        </calcite-flow>`);
-                const activeItemBackButton = await page.find(`${itemTag}:last-of-type >>> .${ITEM_CSS.backButton}`);
-                await activeItemBackButton.click();
-                const items = await page.findAll(itemTag);
-                expect(items).toHaveLength(1);
-                expect(items[0].id).toBe("first");
-            });
-            it("setting 'beforeBack' should be called in 'back()'", async () => {
-                const page = await newE2EPage();
-                const mockCallBack = jest.fn().mockReturnValue(Promise.resolve());
-                await page.exposeFunction("beforeBack", mockCallBack);
-                await page.setContent(`<calcite-flow><${itemTag}></${itemTag}></calcite-flow>`);
-                await page.$eval(itemTag, (elm) => (elm.beforeBack = window.beforeBack));
-                const flow = await page.find("calcite-flow");
-                const backValue = await flow.callMethod("back");
-                expect(backValue).toBeDefined();
-                expect(mockCallBack).toHaveBeenCalledTimes(1);
-            });
-            it("frame advancing should add animation class", async () => {
-                const page = await newE2EPage();
-                await page.setContent(`<calcite-flow><${itemTag}></${itemTag}></calcite-flow>`);
-                const items = await page.findAll(itemTag);
-                expect(items).toHaveLength(1);
-                const element = await page.find("calcite-flow");
-                element.innerHTML = `<${itemTag}>test</${itemTag}><${itemTag}>test</${itemTag}>`;
-                await page.waitForChanges();
-                const items2 = await page.findAll(itemTag);
-                expect(items2).toHaveLength(2);
-                const frame = await page.find(`calcite-flow >>> .${CSS.frame}`);
-                expect(frame).toHaveClass(CSS.frameAdvancing);
-            });
-            it("frame advancing should add animation class when subtree is modified", async () => {
-                const page = await newE2EPage();
-                await page.setContent(`<calcite-flow><${itemTag}>flow1</${itemTag}></calcite-flow>`);
-                const element = await page.find("calcite-flow");
-                element.innerHTML = `<${itemTag}>flow1</${itemTag}><${itemTag} id="flow2">flow2</${itemTag}>`;
-                await page.waitForChanges();
-                const item2 = await page.find(`${itemTag}[id=flow2]`);
-                item2.innerHTML = "new flow2 subtree content";
-                await page.waitForChanges();
-                const frame = await page.find(`calcite-flow >>> .${CSS.frame}`);
-                expect(frame).toHaveClass(CSS.frameAdvancing);
-            });
-            it("frame retreating should add animation class", async () => {
-                const page = await newE2EPage();
-                await page.setContent("<calcite-flow></calcite-flow>");
-                await page.$eval("calcite-flow", (elm, itemTag) => {
-                    elm.innerHTML = `
-      <${itemTag}></${itemTag}>
-      <${itemTag}></${itemTag}>
-      <${itemTag}></${itemTag}>
-      `;
-                }, itemTag);
-                await page.waitForChanges();
-                const items = await page.findAll(itemTag);
-                expect(items).toHaveLength(3);
-                const frame = await page.find(`calcite-flow >>> .${CSS.frame}`);
-                expect(frame).not.toHaveClass(CSS.frameRetreating);
-                expect(frame).not.toHaveClass(CSS.frameAdvancing);
-                await page.$eval("calcite-flow", (elm) => elm.back());
-                await page.waitForChanges();
-                const items2 = await page.findAll(itemTag);
-                expect(items2).toHaveLength(2);
-                const frame2 = await page.find(`calcite-flow >>> .${CSS.frame}`);
-                expect(frame2).toHaveClass(CSS.frameRetreating);
-                expect(frame2).not.toHaveClass(CSS.frameAdvancing);
-            });
-            it("frame animation class should not exist if frame count remains the same", async () => {
-                const page = await newE2EPage();
-                await page.setContent(`<calcite-flow><${itemTag}>test</${itemTag}><${itemTag}>test</${itemTag}></calcite-flow>`);
-                const frame = await page.find(`calcite-flow >>> .${CSS.frame}`);
-                expect(frame).not.toHaveClass(CSS.frameRetreating);
-                expect(frame).not.toHaveClass(CSS.frameAdvancing);
-                const element = await page.find("calcite-flow");
-                element.innerHTML = `<${itemTag}>test</${itemTag}><${itemTag}>test</${itemTag}>`;
-                await page.waitForChanges();
-                expect(frame).not.toHaveClass(CSS.frameRetreating);
-                expect(frame).not.toHaveClass(CSS.frameAdvancing);
-            });
-            it("panel properties should be set", async () => {
-                const page = await newE2EPage();
-                await page.setContent("<calcite-flow></calcite-flow>");
-                await page.$eval("calcite-flow", (elm, itemTag) => {
-                    elm.innerHTML = `
-      <${itemTag}></${itemTag}>
-      <${itemTag}></${itemTag}>
-      <${itemTag}></${itemTag}>
-      `;
-                }, itemTag);
-                const items = await page.findAll(itemTag);
-                expect(items).toHaveLength(3);
-                const showBackButton0 = await items[0].getProperty("showBackButton");
-                const showBackButton2 = await items[2].getProperty("showBackButton");
-                expect(items[0].getAttribute("hidden")).not.toBe(null);
-                expect(showBackButton0).not.toBe(null);
-                expect(items[2].getAttribute("hidden")).toBe(null);
-                expect(showBackButton2).not.toBe(null);
-            });
-            it("should be accessible", async () => accessible(html `
-    <calcite-flow>
-      <${itemTag}>
-      </${itemTag}>
-      <${itemTag}>
-      </${itemTag}>
-      <${itemTag}>
-      </${itemTag}>
-    </calcite-flow>
-    `));
-            it("should also work with descendant slotted items", async () => {
-                const page = await newE2EPage();
-                await page.setContent(html `<calcite-flow>
-      <${itemTag}>Valid panel</${itemTag}>
-      <${itemTag}>Valid panel</${itemTag}>
-      <div>
-        <${itemTag}>Allowed panel <${itemTag}>Disallowed panel</${itemTag}></${itemTag}>
-      </div>
-    </calcite-flow>`);
-                const items = await page.findAll(itemTag);
-                expect(items).toHaveLength(4);
-                expect(items[0].getAttribute("hidden")).toBe("");
-                expect(await items[0].getProperty("showBackButton")).toBe(false);
-                expect(items[1].getAttribute("hidden")).toBe("");
-                expect(await items[1].getProperty("showBackButton")).toBe(false);
-                expect(items[2].getAttribute("hidden")).toBe(null);
-                expect(await items[2].getProperty("showBackButton")).toBe(true);
-                expect(items[3].getAttribute("hidden")).toBe(null);
-                expect(await items[3].getProperty("showBackButton")).toBe(false);
-            });
-        }
-    });
-});

package/dist/collection/components/flow-item/flow-item.e2e.js

@@ -1,72 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { accessible, defaults, disabled, focusable, hidden, renders, slots } from "../../tests/commonTests";
-import { CSS, SLOTS } from "./resources";
-describe("calcite-flow-item", () => {
-    it("renders", async () => renders("calcite-flow-item", { display: "flex" }));
-    it("honors hidden attribute", async () => hidden("calcite-flow-item"));
-    it("has property defaults", async () => defaults("calcite-flow-item", [
-        {
-            propertyName: "closable",
-            defaultValue: false
-        },
-        {
-            propertyName: "closed",
-            defaultValue: false
-        },
-        {
-            propertyName: "disabled",
-            defaultValue: false
-        },
-        {
-            propertyName: "loading",
-            defaultValue: false
-        },
-        {
-            propertyName: "menuOpen",
-            defaultValue: false
-        },
-        {
-            propertyName: "showBackButton",
-            defaultValue: false
-        }
-    ]));
-    it("has slots", () => slots("calcite-flow-item", SLOTS));
-    it("can be disabled", () => disabled(`<calcite-flow-item closable>scrolling content</calcite-flow-item>`));
-    it("should be accessible", async () => accessible(`
-    <calcite-flow-item>
-      <div slot="${SLOTS.headerActionsStart}">test start</div>
-      <div slot="${SLOTS.headerContent}">test content</div>
-      <div slot="${SLOTS.headerActionsEnd}">test end</div>
-      <p>Content</p>
-      <calcite-button slot="${SLOTS.footerActions}">test button 1</calcite-button>
-      <calcite-button slot="${SLOTS.footerActions}">test button 2</calcite-button>
-    </calcite-flow-item>
-    `));
-    it("should focus on back button", async () => focusable(`<calcite-flow-item show-back-button>test</calcite-flow-item>`, {
-        shadowFocusTargetSelector: "calcite-action"
-    }));
-    it("showBackButton", async () => {
-        const page = await newE2EPage();
-        await page.setContent("<calcite-flow-item></calcite-flow-item>");
-        const element = await page.find("calcite-flow-item");
-        const showBackButton = await element.getProperty("showBackButton");
-        expect(showBackButton).toBe(false);
-        const backButton = await page.find(`calcite-flow-item >>> .${CSS.backButton}`);
-        expect(backButton).toBeNull();
-        element.setProperty("showBackButton", true);
-        await page.waitForChanges();
-        const showBackButtonNew = await element.getProperty("showBackButton");
-        expect(showBackButtonNew).toBe(true);
-        const backButtonNew = await page.find(`calcite-flow-item >>> .${CSS.backButton}`);
-        expect(backButtonNew).not.toBeNull();
-        expect(await backButtonNew.isVisible()).toBe(true);
-        const calciteFlowItemBackClick = await page.spyOnEvent("calciteFlowItemBackClick", "window");
-        const calciteFlowItemBack = await page.spyOnEvent("calciteFlowItemBack", "window");
-        await page.$eval("calcite-flow-item", (elm) => {
-            const nativeBackButton = elm.shadowRoot.querySelector(`calcite-action`);
-            nativeBackButton.click();
-        });
-        expect(calciteFlowItemBackClick).toHaveReceivedEvent();
-        expect(calciteFlowItemBack).toHaveReceivedEvent();
-    });
-});

package/dist/collection/components/functional/Heading.spec.js

@@ -1,33 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { h, Component } from "@stencil/core";
-import { newSpecPage } from "@stencil/core/testing";
-import { Heading, constrainHeadingLevel } from "./Heading";
-describe("constrainHeadingLevel", () => {
-    it("should constrain heading levels", () => {
-        expect(constrainHeadingLevel(10)).toEqual(6);
-        expect(constrainHeadingLevel(6)).toEqual(6);
-        expect(constrainHeadingLevel(5)).toEqual(5);
-        expect(constrainHeadingLevel(1)).toEqual(1);
-        expect(constrainHeadingLevel(0)).toEqual(1);
-        expect(constrainHeadingLevel(3.14)).toEqual(4);
-    });
-});
-let Dummy = class Dummy {
-};
-Dummy = __decorate([
-    Component({ tag: "dummy-component" })
-], Dummy);
-describe("Heading", () => {
-    it("should render", async () => {
-        const page = await newSpecPage({
-            components: [Dummy],
-            template: () => (h(Heading, { class: "test", level: 1 }, "My Heading"))
-        });
-        expect(page.root).toEqualHtml(`<h1 class="test">My Heading</h1>`);
-    });
-});