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

package/dist/collection/utils/dom.spec.js

@@ -1,273 +0,0 @@
-import { getElementProp, getSlotted, setRequestedIcon, ensureId, getThemeName, toAriaBoolean } from "./dom";
-import { guidPattern } from "./guid.spec";
-import { html } from "../../support/formatting";
-describe("dom", () => {
-    describe("getElementProp()", () => {
-        describe("light DOM", () => {
-            it("returns match if found on self", async () => {
-                document.body.innerHTML = `
-        <div>
-          <div>
-            <div id="test" test-prop="self"></div>
-          </div>
-        </div>
-      `;
-                expect(getElementProp(document.getElementById("test"), "test-prop", "not-found")).toBe("self");
-            });
-            it("returns first ancestral match", async () => {
-                document.body.innerHTML = `
-        <div test-prop="root">
-          <div>
-            <div id="test" ></div>
-          </div>
-        </div>
-      `;
-                expect(getElementProp(document.getElementById("test"), "test-prop", "not-found")).toBe("root");
-            });
-            it("returns fallback if no match is found", async () => {
-                document.body.innerHTML = `
-        <div>
-          <div>
-            <div id="test"></div>
-          </div>
-        </div>
-      `;
-                expect(getElementProp(document.getElementById("test"), "test-prop", "not-found")).toBe("not-found");
-            });
-        });
-        describe("shadow DOM boundaries", () => {
-            function defineTestComponents() {
-                class PropLookupParentTest extends HTMLElement {
-                    constructor() {
-                        super();
-                        this.attachShadow({ mode: "open" });
-                    }
-                    connectedCallback() {
-                        this.shadowRoot.innerHTML = `<prop-lookup-child-test></prop-lookup-child-test>`;
-                    }
-                }
-                class PropLookupChildTest extends HTMLElement {
-                    constructor() {
-                        super();
-                        this.attachShadow({ mode: "open" });
-                    }
-                    connectedCallback() {
-                        this.shadowRoot.innerHTML = "<div>😄</div>";
-                    }
-                }
-                customElements.define("prop-lookup-parent-test", PropLookupParentTest);
-                customElements.define("prop-lookup-child-test", PropLookupChildTest);
-            }
-            beforeEach(defineTestComponents);
-            it("does not cross shadow DOM boundary (default)", () => {
-                document.body.innerHTML = `
-        <prop-lookup-parent-test id="test" test-prop="parent"></prop-lookup-parent-test>
-      `;
-                expect(getElementProp(document.getElementById("test").shadowRoot.firstElementChild, "test-prop", "not-found")).toBe("not-found");
-            });
-        });
-    });
-    describe("getSlotted()", () => {
-        const testSlotName = "test";
-        const testSlotName2 = "test2";
-        function getTestComponent() {
-            return document.body.querySelector("slot-test");
-        }
-        function defineTestComponents() {
-            class SlotTest extends HTMLElement {
-                constructor() {
-                    super();
-                    this.attachShadow({ mode: "open" });
-                }
-                connectedCallback() {
-                    this.shadowRoot.innerHTML = html `
-            <slot name="${testSlotName}"></slot>
-            <slot name="${testSlotName2}"></slot>
-            <slot></slot>
-          `;
-                }
-            }
-            customElements.define("slot-test", SlotTest);
-        }
-        beforeEach(() => {
-            defineTestComponents();
-            document.body.innerHTML = `
-      <slot-test>
-        <h2 slot=${testSlotName}>
-          <span>😃</span>
-          <span>🙂</span>
-        </h2>
-        <h2 slot=${testSlotName}><span>😂</span></h2>
-        <h3 slot=${testSlotName2}><span>😂</span></h3>
-        <div id="default-slot-el"><p>🙂</p></div>
-      </slot-test>
-    `;
-        });
-        describe("single slotted", () => {
-            it("returns elements with matching default slot", () => expect(getSlotted(getTestComponent())).toBeTruthy());
-            it("returns elements with matching slot name", () => expect(getSlotted(getTestComponent(), testSlotName)).toBeTruthy());
-            it("returns elements with matching slot names", () => expect(getSlotted(getTestComponent(), [testSlotName, testSlotName2])).toBeTruthy());
-            it("returns null when no results", () => expect(getSlotted(getTestComponent(), "non-existent-slot")).toBeNull());
-            describe("scoped selector", () => {
-                it("returns element with matching default slot", () => expect(getSlotted(getTestComponent(), { selector: "p" })).toBeTruthy());
-                it("returns element with matching nested selector", () => expect(getSlotted(getTestComponent(), testSlotName, { selector: "span" })).toBeTruthy());
-                it("returns nothing with non-matching child selector", () => expect(getSlotted(getTestComponent(), testSlotName, {
-                    selector: "non-existent-slot"
-                })).toBeNull());
-            });
-            describe("direct slotted children", () => {
-                it("returns element if slot is child of element", () => {
-                    document.body.innerHTML = `
-            <slot-test>
-              <h2 slot=${testSlotName}><span>😂</span></h2>
-              <some-other-element>
-                <h2 slot=${testSlotName}><span>🙃</span></h2>
-              </some-other-element>
-            </slot-test>
-          `;
-                    expect(getSlotted(getTestComponent(), testSlotName, {
-                        direct: true
-                    })).toBeTruthy();
-                });
-                it("returns null if slot is nested", () => {
-                    document.body.innerHTML = `
-            <slot-test>
-              <some-other-element>
-                <h2 slot=${testSlotName}><span>🙃</span></h2>
-              </some-other-element>
-            </slot-test>
-          `;
-                    expect(getSlotted(getTestComponent(), testSlotName, {
-                        all: true,
-                        direct: true
-                    })).toBeTruthy();
-                });
-            });
-        });
-        describe("multiple slotted", () => {
-            it("returns element with default slot name", () => expect(getSlotted(getTestComponent(), { all: true })).toHaveLength(1));
-            it("returns elements with matching slot name", () => expect(getSlotted(getTestComponent(), testSlotName, { all: true })).toHaveLength(2));
-            it("returns elements with matching slot names", () => expect(getSlotted(getTestComponent(), [testSlotName, testSlotName2], { all: true })).toHaveLength(3));
-            it("returns empty list when no results", () => expect(getSlotted(getTestComponent(), "non-existent-slot", { all: true })).toHaveLength(0));
-            describe("scoped selector", () => {
-                it("returns child elements matching selector", () => expect(getSlotted(getTestComponent(), testSlotName, {
-                    all: true,
-                    selector: "span"
-                })).toHaveLength(3));
-                it("returns empty list with non-matching child selector", () => expect(getSlotted(getTestComponent(), testSlotName, {
-                    all: true,
-                    selector: "non-existent"
-                })).toHaveLength(0));
-            });
-            describe("direct slotted children", () => {
-                it("returns child elements if children are direct descendants", () => {
-                    document.body.innerHTML = `
-            <slot-test>
-              <h2 slot=${testSlotName}><span>😃</span></h2>
-              <some-other-element>
-                <h2 slot=${testSlotName}><span>🙃</span></h2>
-              </some-other-element>
-            </slot-test>
-          `;
-                    expect(getSlotted(getTestComponent(), testSlotName, {
-                        all: true,
-                        direct: true
-                    })).toHaveLength(1);
-                });
-                it("returns empty list if children are nested", () => {
-                    document.body.innerHTML = `
-            <slot-test>
-              <some-other-element>
-                <h2 slot=${testSlotName}><span>😃</span></h2>
-                <h2 slot=${testSlotName}><span>🙃</span></h2>
-              </some-other-element>
-            </slot-test>
-          `;
-                    expect(getSlotted(getTestComponent(), testSlotName, {
-                        all: true,
-                        direct: true
-                    })).toHaveLength(0);
-                });
-            });
-        });
-    });
-    describe("setRequestedIcon()", () => {
-        it("returns the custom icon name if custom value is passed", () => expect(setRequestedIcon({ exampleValue: "exampleReturnedValue" }, "mycustomvalue", "exampleValue")).toBe("mycustomvalue"));
-        it("returns the pre-defined icon name if custom value is not passed", () => expect(setRequestedIcon({ exampleValue: "exampleReturnedValue" }, "", "exampleValue")).toBe("exampleReturnedValue"));
-    });
-    describe("uniqueId", () => {
-        it("generates unique ID on an element", () => {
-            const input = document.createElement("input");
-            expect(ensureId(input)).toMatch(new RegExp(`input-${guidPattern.source}`));
-        });
-        it("returns the element's ID if it exists", () => {
-            const input = document.createElement("input");
-            input.id = "test";
-            expect(ensureId(input)).toBe("test");
-        });
-        it("returns empty string if invoked without element", () => {
-            expect(ensureId(null)).toBe("");
-        });
-    });
-    describe("getThemeName()", () => {
-        function getTestComponentTheme() {
-            return document.body.querySelector("themed-element").foundThemeName;
-        }
-        function defineTestComponents() {
-            class ThemedElement extends HTMLElement {
-                constructor() {
-                    super();
-                    this.foundThemeName = null;
-                    this.attachShadow({ mode: "open" });
-                }
-                connectedCallback() {
-                    this.foundThemeName = getThemeName(this);
-                }
-            }
-            customElements.define("themed-element", ThemedElement);
-        }
-        beforeEach(() => {
-            defineTestComponents();
-        });
-        it("finds the closest theme if set (light)", () => {
-            document.body.innerHTML = html `
-        <div class="calcite-theme-dark">
-          <div class="calcite-theme-light">
-            <themed-element></themed-element>
-          </div>
-        </div>
-      `;
-            expect(getTestComponentTheme()).toBe("light");
-        });
-        it("finds the closest theme if set (dark)", () => {
-            document.body.innerHTML = html `
-        <div class="calcite-theme-light">
-          <div class="calcite-theme-dark">
-            <themed-element></themed-element>
-          </div>
-        </div>
-      `;
-            expect(getTestComponentTheme()).toBe("dark");
-        });
-        it("sets to default (light) if no theme is set", () => {
-            document.body.innerHTML = html `
-        <div>
-          <div>
-            <themed-element></themed-element>
-          </div>
-        </div>
-      `;
-            expect(getTestComponentTheme()).toBe("light");
-        });
-    });
-    describe("toAriaBoolean()", () => {
-        it("handles truthy values", () => {
-            expect(toAriaBoolean(true)).toBe("true");
-        });
-        it("handles falsy values", () => {
-            expect(toAriaBoolean(false)).toBe("false");
-            expect(toAriaBoolean(null)).toBe("false");
-            expect(toAriaBoolean(undefined)).toBe("false");
-        });
-    });
-});

package/dist/collection/utils/floating-ui.spec.js

@@ -1,23 +0,0 @@
-import { getEffectivePlacement, defaultOffsetDistance, filterComputedPlacements, placements, effectivePlacements } from "./floating-ui";
-it("should set calcite placement to FloatingUI placement", () => {
-    const el = document.createElement("div");
-    expect(getEffectivePlacement(el, "leading")).toBe("left");
-    expect(getEffectivePlacement(el, "leading-start")).toBe("left-start");
-    expect(getEffectivePlacement(el, "leading-end")).toBe("left-end");
-    expect(getEffectivePlacement(el, "trailing")).toBe("right");
-    expect(getEffectivePlacement(el, "trailing-start")).toBe("right-start");
-    expect(getEffectivePlacement(el, "trailing-end")).toBe("right-end");
-    el.dir = "rtl";
-    expect(getEffectivePlacement(el, "leading")).toBe("right");
-    expect(getEffectivePlacement(el, "leading-start")).toBe("right-start");
-    expect(getEffectivePlacement(el, "leading-end")).toBe("right-end");
-    expect(getEffectivePlacement(el, "trailing")).toBe("left");
-    expect(getEffectivePlacement(el, "trailing-start")).toBe("left-start");
-    expect(getEffectivePlacement(el, "trailing-end")).toBe("left-end");
-});
-it("should have correct value for defaultOffsetDistance", () => {
-    expect(defaultOffsetDistance).toBe(6);
-});
-it("should filter computed placements", () => {
-    expect(new Set(filterComputedPlacements(placements, document.createElement("div")))).toEqual(new Set(effectivePlacements));
-});

package/dist/collection/utils/form.spec.js

@@ -1,16 +0,0 @@
-import { submitForm } from "./form";
-describe("form", () => {
-    it("has a `submitForm()` util", () => {
-        const formEl = document.createElement("form");
-        const formOwner = { formEl };
-        const submitSpy = jest.fn();
-        formEl.requestSubmit = submitSpy;
-        let submitted = submitForm(formOwner);
-        expect(submitted).toBe(true);
-        expect(submitSpy).toBeCalledTimes(1);
-        formOwner.formEl = null;
-        submitted = submitForm(formOwner);
-        expect(submitted).toBe(false);
-        expect(submitSpy).toBeCalledTimes(1);
-    });
-});

package/dist/collection/utils/globalAttributes.spec.js

@@ -1,36 +0,0 @@
-import { unwatchGlobalAttributes, watchGlobalAttributes } from "./globalAttributes";
-import { JSDOM } from "jsdom";
-import { Build } from "@stencil/core";
-import { waitForAnimationFrame } from "../tests/utils";
-describe("globalAttributes", () => {
-    const originalIsBrowser = Build.isBrowser;
-    beforeAll(() => (Build.isBrowser = true));
-    afterAll(() => (Build.isBrowser = originalIsBrowser));
-    it("sets component's global attributes when watching", async () => {
-        // we clobber Stencil's custom Mock document implementation
-        const { window: win } = new JSDOM();
-        window = win; // make window references use JSDOM
-        const fakeComponent = win.document.createElement("fake-component");
-        win.document.body.append(fakeComponent);
-        const globalComponent = {
-            el: fakeComponent,
-            globalAttributes: {}
-        };
-        watchGlobalAttributes(globalComponent, ["lang"]);
-        await waitForAnimationFrame();
-        expect(globalComponent.globalAttributes).toEqual({});
-        fakeComponent.setAttribute("lang", "en");
-        await waitForAnimationFrame();
-        expect(globalComponent.globalAttributes).toEqual({ lang: "en" });
-        fakeComponent.setAttribute("title", "untracked global attr should not be set");
-        await waitForAnimationFrame();
-        expect(globalComponent.globalAttributes).toEqual({ lang: "en" });
-        fakeComponent.setAttribute("lang", "es");
-        await waitForAnimationFrame();
-        expect(globalComponent.globalAttributes).toEqual({ lang: "es" });
-        unwatchGlobalAttributes(globalComponent);
-        fakeComponent.setAttribute("lang", "fr");
-        await waitForAnimationFrame();
-        expect(globalComponent.globalAttributes).toEqual({ lang: "es" });
-    });
-});

package/dist/collection/utils/guid.spec.js

@@ -1,7 +0,0 @@
-import { guid } from "./guid";
-export const guidPattern = /\w{8}-\w{4}-\w{4}-\w{4}-\w{12}/;
-describe("guid", () => {
-    it("returns a 36 character guid", () => {
-        expect(guid()).toMatch(guidPattern);
-    });
-});

package/dist/collection/utils/interactive.spec.js

@@ -1,20 +0,0 @@
-import { updateHostInteraction } from "./interactive";
-describe("interactive", () => {
-    it("updateHostInteraction", () => {
-        document.body.innerHTML = `
-          <fake-interactive></fake-interactive>
-      `;
-        const fakeInteractiveEl = document.querySelector("fake-interactive");
-        const fakeInteractive = {
-            el: fakeInteractiveEl,
-            disabled: false
-        };
-        updateHostInteraction(fakeInteractive);
-        expect(fakeInteractiveEl.getAttribute("tabindex")).toBeNull();
-        expect(fakeInteractiveEl.getAttribute("aria-disabled")).toBeNull();
-        fakeInteractive.disabled = true;
-        updateHostInteraction(fakeInteractive);
-        expect(fakeInteractiveEl.getAttribute("tabindex")).toBe("-1");
-        expect(fakeInteractiveEl.getAttribute("aria-disabled")).toBe("true");
-    });
-});

package/dist/collection/utils/label.spec.js

@@ -1,188 +0,0 @@
-import { connectLabel, disconnectLabel, getLabelText, labelClickEvent } from "./label";
-describe("label", () => {
-    function createFakeLabelable(overrides) {
-        const base = {
-            disabled: null,
-            el: null,
-            label: null,
-            labelEl: null,
-            onLabelClick: jest.fn()
-        };
-        return { ...base, ...overrides };
-    }
-    describe("connectLabel/disconnectLabel", () => {
-        describe("wires up the associated label", () => {
-            /**
-             * This util helps simulate calcite-label's behavior since we cannot use the component here
-             *
-             * @param label
-             */
-            function wireUpFakeLabel(label) {
-                label.addEventListener("click", (event) => {
-                    label.dispatchEvent(new CustomEvent(labelClickEvent, { detail: { sourceEvent: event } }));
-                });
-            }
-            it("ignores labelable with no associated label", () => {
-                document.body.innerHTML = `
-          <fake-labelable id="unlabeled"></fake-labelable>
-      `;
-                const fakeLabelableEl = document.querySelector("#unlabeled");
-                const nonLabelable = createFakeLabelable({
-                    el: fakeLabelableEl
-                });
-                connectLabel(nonLabelable);
-                expect(nonLabelable.labelEl).toBeNull();
-                disconnectLabel(nonLabelable);
-                expect(nonLabelable.labelEl).toBeNull();
-            });
-            it("prevents selecting disabled labeled element", () => {
-                document.body.innerHTML = `
-        <calcite-label for="for">label</calcite-label>
-        <fake-labelable id="for"></fake-labelable>
-      `;
-                const labelEl = document.querySelector("calcite-label");
-                const fakeLabelableEl = document.querySelector("#for");
-                wireUpFakeLabel(labelEl);
-                const labelable = createFakeLabelable({
-                    el: fakeLabelableEl,
-                    disabled: true
-                });
-                connectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(0);
-                disconnectLabel(labelable);
-            });
-            it("supports for attribute", () => {
-                document.body.innerHTML = `
-        <calcite-label for="for">label</calcite-label>
-        <fake-labelable id="for"></fake-labelable>
-      `;
-                const labelEl = document.querySelector("calcite-label");
-                const fakeLabelableEl = document.querySelector("#for");
-                wireUpFakeLabel(labelEl);
-                const labelable = createFakeLabelable({
-                    el: fakeLabelableEl
-                });
-                connectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-                disconnectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-            });
-            it("supports wrapped labelable", () => {
-                document.body.innerHTML = `
-        <calcite-label>
-          label
-          <fake-labelable></fake-labelable>
-        </calcite-label>
-      `;
-                const labelEl = document.querySelector("calcite-label");
-                const fakeLabelableEl = document.querySelector("fake-labelable");
-                wireUpFakeLabel(labelEl);
-                const labelable = createFakeLabelable({
-                    el: fakeLabelableEl
-                });
-                connectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-                disconnectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-            });
-            it("supports being rendered after labelable", () => {
-                document.body.innerHTML = `
-          <fake-labelable id="renderedFirst"></fake-labelable>
-        `;
-                const label = document.createElement("calcite-label");
-                label.setAttribute("for", "renderedFirst");
-                document.body.appendChild(label);
-                const labelEl = document.querySelector("calcite-label");
-                const fakeLabelableEl = document.querySelector("fake-labelable");
-                wireUpFakeLabel(labelEl);
-                const labelable = createFakeLabelable({
-                    el: fakeLabelableEl
-                });
-                connectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-                disconnectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-            });
-            it("works if reattached to labelable", () => {
-                document.body.innerHTML = `
-          <calcite-label for="for"></calcite-label>
-          <fake-labelable id="for"></fake-labelable>
-        `;
-                document.querySelector("calcite-label").remove();
-                const label = document.createElement("calcite-label");
-                label.setAttribute("for", "for");
-                document.body.appendChild(label);
-                const labelEl = document.querySelector("calcite-label");
-                const fakeLabelableEl = document.querySelector("fake-labelable");
-                wireUpFakeLabel(labelEl);
-                const labelable = createFakeLabelable({
-                    el: fakeLabelableEl
-                });
-                connectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-                disconnectLabel(labelable);
-                expect(labelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
-            });
-            it("does not support nested labelables", () => {
-                document.body.innerHTML = `
-        <calcite-label>
-          label
-          <fake-labelable id="outer">
-            <fake-labelable id="inner"></fake-labelable>
-          </fake-labelable>
-        </calcite-label>
-      `;
-                const labelEl = document.querySelector("calcite-label");
-                const fakeInnerLabelableEl = document.querySelector("#inner");
-                const fakeOuterLabelableEl = document.querySelector("#outer");
-                wireUpFakeLabel(labelEl);
-                const innerLabelable = createFakeLabelable({
-                    el: fakeInnerLabelableEl
-                });
-                connectLabel(innerLabelable);
-                expect(innerLabelable.labelEl).toBeNull();
-                const outerLabelable = createFakeLabelable({
-                    el: fakeOuterLabelableEl
-                });
-                connectLabel(outerLabelable);
-                expect(outerLabelable.labelEl).toBe(labelEl);
-                labelEl.click();
-                expect(outerLabelable.onLabelClick).toHaveBeenCalledTimes(1);
-                disconnectLabel(outerLabelable);
-                labelEl.click();
-                expect(outerLabelable.onLabelClick).toHaveBeenCalledTimes(1);
-            });
-        });
-    });
-    it("getLabelText", () => {
-        const label = "from-label";
-        expect(getLabelText(createFakeLabelable({ label }))).toBe("from-label");
-        const labelEl = document.createElement("calcite-label");
-        labelEl.textContent = "from-text-content";
-        expect(getLabelText(createFakeLabelable({
-            labelEl
-        }))).toBe("from-text-content");
-        expect(getLabelText(createFakeLabelable({
-            label,
-            labelEl
-        }))).toBe("from-label");
-    });
-});

package/dist/collection/utils/locale.spec.js

@@ -1,44 +0,0 @@
-import { delocalizeNumberString, localizeNumberString, locales } from "./locale";
-const localesWithIssues = ["ar"]; // arabic has different numeral characters
-describe("localizeNumberString and delocalizeNumberString", () => {
-    locales
-        .filter((locale) => !localesWithIssues.includes(locale))
-        .forEach((locale) => {
-        it(`integers localize and delocalize in "${locale}"`, () => {
-            const numberString = "555";
-            const localizedNumberString = localizeNumberString(numberString, locale);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe(numberString);
-        });
-        it(`negative numbers localize and delocalize in "${locale}"`, () => {
-            const numberString = "-123";
-            const localizedNumberString = localizeNumberString(numberString, locale);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe(numberString);
-        });
-        it(`floating point numbers localize and delocalize in "${locale}"`, () => {
-            const numberString = "4.321";
-            const localizedNumberString = localizeNumberString(numberString, locale);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe(numberString);
-        });
-        it(`exponential numbers localize and delocalize in "${locale}"`, () => {
-            const numberString = "2.5e-3";
-            const localizedNumberString = localizeNumberString(numberString, locale);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe(numberString);
-        });
-        it(`numbers with group separators localize and delocalize in "${locale}"`, () => {
-            const numberString = "1,234";
-            const localizedNumberString = localizeNumberString(numberString, locale, true);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe("1234");
-        });
-        it(`floating point numbers with group separators localize and delocalize in "${locale}"`, () => {
-            const numberString = "12,345,678.9";
-            const localizedNumberString = localizeNumberString(numberString, locale, true);
-            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
-            expect(delocalizedNumberString).toBe("12345678.9");
-        });
-    });
-});

package/dist/collection/utils/math.spec.js

@@ -1,8 +0,0 @@
-import { clamp } from "./math";
-describe("clamp", () => {
-    it("clamps numbers within min/max", () => {
-        expect(clamp(5, 0, 10)).toBe(5);
-        expect(clamp(-1, 0, 10)).toBe(0);
-        expect(clamp(11, 0, 10)).toBe(10);
-    });
-});