@duetds/components 8.0.6 → 8.1.1

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

@@ -3,138 +3,138 @@
  */
 import { clamp, roundTo, SafeParseFloat } from "./math.utils";
 describe("math utils", () => {
-  describe("roundTo", () => {
-    it("should round to whole numbers", () => {
-      expect(roundTo(123, 5)).toBe(125);
-      expect(roundTo(111, 5)).toBe(110);
+    describe("roundTo", () => {
+        it("should round to whole numbers", () => {
+            expect(roundTo(123, 5)).toBe(125);
+            expect(roundTo(111, 5)).toBe(110);
+        });
+        it("should round to negative whole numbers", () => {
+            expect(roundTo(-123, 5)).toBe(-125);
+            expect(roundTo(-111, 5)).toBe(-110);
+        });
+        it("should round to decimal numbers", () => {
+            expect(roundTo(1.3, 0.5)).toBe(1.5);
+            expect(roundTo(1.2, 0.5)).toBe(1);
+            expect(roundTo(1.2, 1.5)).toBe(1.5);
+        });
+        it("should round to negative decimal numbers", () => {
+            expect(roundTo(-1.3, 0.5)).toBe(-1.5);
+            expect(roundTo(-1.2, 0.5)).toBe(-1);
+            expect(roundTo(-1.2, 1.5)).toBe(-1.5);
+        });
+    });
+    describe("clamp", () => {
+        it("should return value if in range", () => {
+            expect(clamp(5, 0, 10)).toBe(5);
+        });
+        it("should return min if value < min", () => {
+            expect(clamp(-5, 0, 10)).toBe(0);
+        });
+        it("should return max if value > max", () => {
+            expect(clamp(15, 0, 10)).toBe(10);
+        });
+        it("should return max if value > max for negative min", () => {
+            expect(clamp(15, -10, 10)).toBe(10);
+        });
+        it("should return min if value < min for negative min", () => {
+            expect(clamp(-15, -10, 10)).toBe(-10);
+        });
+    });
+    describe("SafeParseFloat with locale", () => {
+        it("should parse numbers in Swedish locale", () => {
+            expect(SafeParseFloat("12345,67", "sv-SE")).toBe(12345.67);
+            expect(SafeParseFloat("12 345,67", "sv-SE")).toBe(12345.67);
+            expect(SafeParseFloat("12 345,67€", "sv-SE")).toBe(12345.67);
+        });
+        it("should parse numbers in Finnish locale", () => {
+            expect(SafeParseFloat("12345,67", "fi-FI")).toBe(12345.67);
+            expect(SafeParseFloat("12 345,67", "fi-FI")).toBe(12345.67);
+            expect(SafeParseFloat("12 345,67€", "fi-FI")).toBe(12345.67);
+        });
+        it("should parse numbers in English locale", () => {
+            expect(SafeParseFloat("12345.67", "en-GB")).toBe(12345.67);
+            expect(SafeParseFloat("12,345.67", "en-GB")).toBe(12345.67);
+            expect(SafeParseFloat("12,345.67€", "en-GB")).toBe(12345.67);
+        });
+        it("should throw if something not a number is supplied", () => {
+            // @ts-ignore
+            expect(() => SafeParseFloat("definitely not a 10100 number ", "it-IT")).toThrow(Error);
+        });
+        it("should support negqative values", () => {
+            // @ts-ignore
+            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
+            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
+            expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
+            expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
+        });
     });
-    it("should round to negative whole numbers", () => {
-      expect(roundTo(-123, 5)).toBe(-125);
-      expect(roundTo(-111, 5)).toBe(-110);
-    });
-    it("should round to decimal numbers", () => {
-      expect(roundTo(1.3, 0.5)).toBe(1.5);
-      expect(roundTo(1.2, 0.5)).toBe(1);
-      expect(roundTo(1.2, 1.5)).toBe(1.5);
-    });
-    it("should round to negative decimal numbers", () => {
-      expect(roundTo(-1.3, 0.5)).toBe(-1.5);
-      expect(roundTo(-1.2, 0.5)).toBe(-1);
-      expect(roundTo(-1.2, 1.5)).toBe(-1.5);
-    });
-  });
-  describe("clamp", () => {
-    it("should return value if in range", () => {
-      expect(clamp(5, 0, 10)).toBe(5);
-    });
-    it("should return min if value < min", () => {
-      expect(clamp(-5, 0, 10)).toBe(0);
-    });
-    it("should return max if value > max", () => {
-      expect(clamp(15, 0, 10)).toBe(10);
-    });
-    it("should return max if value > max for negative min", () => {
-      expect(clamp(15, -10, 10)).toBe(10);
-    });
-    it("should return min if value < min for negative min", () => {
-      expect(clamp(-15, -10, 10)).toBe(-10);
-    });
-  });
-  describe("SafeParseFloat with locale", () => {
-    it("should parse numbers in Swedish locale", () => {
-      expect(SafeParseFloat("12345,67", "sv-SE")).toBe(12345.67);
-      expect(SafeParseFloat("12 345,67", "sv-SE")).toBe(12345.67);
-      expect(SafeParseFloat("12 345,67€", "sv-SE")).toBe(12345.67);
-    });
-    it("should parse numbers in Finnish locale", () => {
-      expect(SafeParseFloat("12345,67", "fi-FI")).toBe(12345.67);
-      expect(SafeParseFloat("12 345,67", "fi-FI")).toBe(12345.67);
-      expect(SafeParseFloat("12 345,67€", "fi-FI")).toBe(12345.67);
-    });
-    it("should parse numbers in English locale", () => {
-      expect(SafeParseFloat("12345.67", "en-GB")).toBe(12345.67);
-      expect(SafeParseFloat("12,345.67", "en-GB")).toBe(12345.67);
-      expect(SafeParseFloat("12,345.67€", "en-GB")).toBe(12345.67);
-    });
-    it("should throw if something not a number is supplied", () => {
-      // @ts-ignore
-      expect(() => SafeParseFloat("definitely not a 10100 number ", "it-IT")).toThrow(Error);
-    });
-    it("should support negqative values", () => {
-      // @ts-ignore
-      expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-      expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-      expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
-      expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
-    });
-  });
 });
 describe("math-utils negative numbers", () => {
-  describe("roundTo", () => {
-    it("should round to negative decimal numbers", () => {
-      expect(roundTo(-1.3, 0.5)).toBe(-1.5);
-      expect(roundTo(-1.2, 0.5)).toBe(-1);
-      expect(roundTo(-1.2, 1.5)).toBe(-1.5);
-    });
-  });
-  describe("clamp", () => {
-    it("should return value if in range", () => {
-      expect(clamp(5, 0, 10)).toBe(5);
-    });
-    it("should return min if value < min", () => {
-      expect(clamp(-5, 0, 10)).toBe(0);
-    });
-    it("should return max if value > max", () => {
-      expect(clamp(15, 0, 10)).toBe(10);
-    });
-    it("should return max if value > max for negative min", () => {
-      expect(clamp(15, -10, 10)).toBe(10);
-    });
-    it("should return min if value < min for negative min", () => {
-      expect(clamp(-15, -10, 10)).toBe(-10);
-    });
-  });
-  describe("SafeParseFloat", () => {
-    it("should parse numbers in Swedish locale", () => {
-      expect(SafeParseFloat("-2", "sv-SE")).toBe(-2);
-      expect(SafeParseFloat("-2 €", "sv-SE")).toBe(-2);
-      expect(SafeParseFloat("-2€", "sv-SE")).toBe(-2);
-      expect(SafeParseFloat("- 2 €", "sv-SE")).toBe(-2);
-    });
-    it("should parse numbers in Finnish locale", () => {
-      expect(SafeParseFloat("-2", "fi-FI")).toBe(-2);
-      expect(SafeParseFloat("-2 €", "fi-FI")).toBe(-2);
-      expect(SafeParseFloat("-2€", "fi-FI")).toBe(-2);
-      expect(SafeParseFloat("- 2 €", "fi-FI")).toBe(-2);
-    });
-    it("should parse numbers in English locale", () => {
-      expect(SafeParseFloat("-2", "en-GB")).toBe(-2);
-      expect(SafeParseFloat("-2 €", "en-GB")).toBe(-2);
-      expect(SafeParseFloat("-2€", "en-GB")).toBe(-2);
-      expect(SafeParseFloat("- 2 €", "en-GB")).toBe(-2);
-    });
-    it("should not throw if unknown locale supplied", () => {
-      // @ts-ignore
-      expect(() => SafeParseFloat("12.345,67", "enokian")).not.toThrow(TypeError);
-    });
-    it("should support negative values", () => {
-      // @ts-ignore
-      expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-      expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-      expect(SafeParseFloat("-12 345.67€", "en-GB")).toBe(-12345.67);
-      expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-      expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-      expect(SafeParseFloat("-12,345.67€", "en-GB")).toBe(-12345.67);
-      expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
-      expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
-      expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
+    describe("roundTo", () => {
+        it("should round to negative decimal numbers", () => {
+            expect(roundTo(-1.3, 0.5)).toBe(-1.5);
+            expect(roundTo(-1.2, 0.5)).toBe(-1);
+            expect(roundTo(-1.2, 1.5)).toBe(-1.5);
+        });
+    });
+    describe("clamp", () => {
+        it("should return value if in range", () => {
+            expect(clamp(5, 0, 10)).toBe(5);
+        });
+        it("should return min if value < min", () => {
+            expect(clamp(-5, 0, 10)).toBe(0);
+        });
+        it("should return max if value > max", () => {
+            expect(clamp(15, 0, 10)).toBe(10);
+        });
+        it("should return max if value > max for negative min", () => {
+            expect(clamp(15, -10, 10)).toBe(10);
+        });
+        it("should return min if value < min for negative min", () => {
+            expect(clamp(-15, -10, 10)).toBe(-10);
+        });
+    });
+    describe("SafeParseFloat", () => {
+        it("should parse numbers in Swedish locale", () => {
+            expect(SafeParseFloat("-2", "sv-SE")).toBe(-2);
+            expect(SafeParseFloat("-2 €", "sv-SE")).toBe(-2);
+            expect(SafeParseFloat("-2€", "sv-SE")).toBe(-2);
+            expect(SafeParseFloat("- 2 €", "sv-SE")).toBe(-2);
+        });
+        it("should parse numbers in Finnish locale", () => {
+            expect(SafeParseFloat("-2", "fi-FI")).toBe(-2);
+            expect(SafeParseFloat("-2 €", "fi-FI")).toBe(-2);
+            expect(SafeParseFloat("-2€", "fi-FI")).toBe(-2);
+            expect(SafeParseFloat("- 2 €", "fi-FI")).toBe(-2);
+        });
+        it("should parse numbers in English locale", () => {
+            expect(SafeParseFloat("-2", "en-GB")).toBe(-2);
+            expect(SafeParseFloat("-2 €", "en-GB")).toBe(-2);
+            expect(SafeParseFloat("-2€", "en-GB")).toBe(-2);
+            expect(SafeParseFloat("- 2 €", "en-GB")).toBe(-2);
+        });
+        it("should not throw if unknown locale supplied", () => {
+            // @ts-ignore
+            expect(() => SafeParseFloat("12.345,67", "enokian")).not.toThrow(TypeError);
+        });
+        it("should support negative values", () => {
+            // @ts-ignore
+            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
+            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
+            expect(SafeParseFloat("-12 345.67€", "en-GB")).toBe(-12345.67);
+            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
+            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
+            expect(SafeParseFloat("-12,345.67€", "en-GB")).toBe(-12345.67);
+            expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
+            expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
+            expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
+        });
     });
-  });
 });

package/lib/collection/utils/picture-utils.js

@@ -3,6 +3,6 @@
  */
 import { h } from "@stencil/core";
 export const DuetPicture = ({ img, sources }) => {
-  return (h("picture", null, sources &&
-    sources.map(source => (h("source", { srcSet: source.srcset, media: source.media, type: source.type, sizes: source.sizes }))), h("img", Object.assign({}, img))));
+    return (h("picture", null, sources &&
+        sources.map(source => (h("source", { srcSet: source.srcset, media: source.media, type: source.type, sizes: source.sizes }))), h("img", Object.assign({}, img))));
 };

package/lib/collection/utils/string-utils.js

@@ -2,29 +2,29 @@
  * Built with Duet Design System
  */
 function isObject(maybeObj) {
-  return Object.prototype.toString.call(maybeObj) === "[object Object]";
+    return Object.prototype.toString.call(maybeObj) === "[object Object]";
 }
 export const parsePossibleJSON = (maybeJSON) => {
-  if (Array.isArray(maybeJSON) || isObject(maybeJSON)) {
-    return maybeJSON;
-  }
-  if (typeof maybeJSON === "string") {
-    try {
-      return JSON.parse(maybeJSON);
+    if (Array.isArray(maybeJSON) || isObject(maybeJSON)) {
+        return maybeJSON;
     }
-    catch (e) {
-      console.warn(e);
-      try {
-        return JSON.parse(convertHtmlQuotes(maybeJSON));
-      }
-      catch (e) {
-        console.warn(e);
-      }
+    if (typeof maybeJSON === "string") {
+        try {
+            return JSON.parse(maybeJSON);
+        }
+        catch (e) {
+            console.warn(e);
+            try {
+                return JSON.parse(convertHtmlQuotes(maybeJSON));
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        }
     }
-  }
-  // undefined is not a type in JSON,
-  // so we use it here to signal invalid input
-  return undefined;
+    // undefined is not a type in JSON,
+    // so we use it here to signal invalid input
+    return undefined;
 };
 /**
  * Format string, via simplistic sprintf equivalent
@@ -33,21 +33,21 @@ export const parsePossibleJSON = (maybeJSON) => {
  */
 // @ts-ignore
 if (!String.format) {
-  // @ts-ignore
-  String.format = function (format) {
-    var args = Array.prototype.slice.call(arguments, 1);
-    return format.replace(/\{\{|\}\}|\{(\d+)\}/g, function (curlyBrack, index) {
-      return curlyBrack == "{{" ? "{" : curlyBrack == "}}" ? "}" : args[index];
-    });
-  };
+    // @ts-ignore
+    String.format = function (format) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        return format.replace(/\{\{|\}\}|\{(\d+)\}/g, function (curlyBrack, index) {
+            return curlyBrack == "{{" ? "{" : curlyBrack == "}}" ? "}" : args[index];
+        });
+    };
 }
 const MATCH_DISALLOWED_CHARS = /[^a-z0-9áéíóúñüöäå \.,_-]/gim;
 export function sanitizeString(string) {
-  return string.replace(MATCH_DISALLOWED_CHARS, "").trim();
+    return string.replace(MATCH_DISALLOWED_CHARS, "").trim();
 }
 export const convertHtmlQuotes = string => {
-  if (typeof string === "string") {
-    return string.replace(/"/g, '"').replace(/'/g, '"');
-  }
-  return string;
+    if (typeof string === "string") {
+        return string.replace(/"/g, '"').replace(/'/g, '"');
+    }
+    return string;
 };

package/lib/collection/utils/string-utils.spec.js

@@ -3,37 +3,37 @@
  */
 import { parsePossibleJSON } from "./string-utils";
 describe("string-utils", () => {
-  describe("parsePossibleString", () => {
-    it("returns exact same object, if object is passed", () => {
-      const object = { hello: "world" };
-      expect(parsePossibleJSON(object)).toBe(object);
+    describe("parsePossibleString", () => {
+        it("returns exact same object, if object is passed", () => {
+            const object = { hello: "world" };
+            expect(parsePossibleJSON(object)).toBe(object);
+        });
+        it("returns exact same array, if array is passed", () => {
+            const array = [{ hello: "world" }];
+            expect(parsePossibleJSON(array)).toBe(array);
+        });
+        it("parses string arguments as JSON", () => {
+            const object = { hello: "world" };
+            const stringifiedObject = JSON.stringify(object);
+            expect(parsePossibleJSON(stringifiedObject)).toEqual(object);
+        });
+        it("gracefully handles malformed/invalid JSON", () => {
+            // spy on console.warn so we can assert it was called, and avoid mess in test output
+            const spy = jest.spyOn(global.console, "warn").mockImplementation(() => jest.fn());
+            // intentionally invalid JSON - unquoted property name
+            const stringifiedObject = '{ hello: "world" }';
+            expect(parsePossibleJSON(stringifiedObject)).toBe(undefined);
+            expect(console.warn).toHaveBeenCalled();
+            spy.mockRestore();
+        });
+        it("returns undefined for other types of data", () => {
+            expect(parsePossibleJSON(null)).toBe(undefined);
+            expect(parsePossibleJSON(undefined)).toBe(undefined);
+            expect(parsePossibleJSON(function () {
+                /*intentionally empty*/
+            })).toBe(undefined);
+            expect(parsePossibleJSON(true)).toBe(undefined);
+            expect(parsePossibleJSON(12345)).toBe(undefined);
+        });
     });
-    it("returns exact same array, if array is passed", () => {
-      const array = [{ hello: "world" }];
-      expect(parsePossibleJSON(array)).toBe(array);
-    });
-    it("parses string arguments as JSON", () => {
-      const object = { hello: "world" };
-      const stringifiedObject = JSON.stringify(object);
-      expect(parsePossibleJSON(stringifiedObject)).toEqual(object);
-    });
-    it("gracefully handles malformed/invalid JSON", () => {
-      // spy on console.warn so we can assert it was called, and avoid mess in test output
-      const spy = jest.spyOn(global.console, "warn").mockImplementation(() => jest.fn());
-      // intentionally invalid JSON - unquoted property name
-      const stringifiedObject = '{ hello: "world" }';
-      expect(parsePossibleJSON(stringifiedObject)).toBe(undefined);
-      expect(console.warn).toHaveBeenCalled();
-      spy.mockRestore();
-    });
-    it("returns undefined for other types of data", () => {
-      expect(parsePossibleJSON(null)).toBe(undefined);
-      expect(parsePossibleJSON(undefined)).toBe(undefined);
-      expect(parsePossibleJSON(function () {
-        /*intentionally empty*/
-      })).toBe(undefined);
-      expect(parsePossibleJSON(true)).toBe(undefined);
-      expect(parsePossibleJSON(12345)).toBe(undefined);
-    });
-  });
 });

package/lib/collection/utils/teleport.js

@@ -9,87 +9,87 @@
  * If your popup has closing animation, use the timeout parameter.
  */
 export class Teleport {
-  constructor(element, target) {
-    this.isActive = false;
-    this.element = element;
-    this.target = target || document.body;
-    this.teleportId = `${Math.random()}-${Date.now()}`.substring(2);
-  }
-  /**
-   * @param makeSiblingsInert - make all siblings of the element inert, use only with modals
-   */
-  go(makeSiblingsInert = false) {
-    // React handles teleporting itself with portals
-    if (!this.element.dataset.reactPortal) {
-      this.stub = document.createElement("template");
-      this.element.insertAdjacentElement("afterend", this.stub);
-      this.target.appendChild(this.element);
+    constructor(element, target) {
+        this.isActive = false;
+        this.element = element;
+        this.target = target || document.body;
+        this.teleportId = `${Math.random()}-${Date.now()}`.substring(2);
     }
-    if (makeSiblingsInert) {
-      this._makeSiblingsInert();
+    /**
+     * @param makeSiblingsInert - make all siblings of the element inert, use only with modals
+     */
+    go(makeSiblingsInert = false) {
+        // React handles teleporting itself with portals
+        if (!this.element.dataset.reactPortal) {
+            this.stub = document.createElement("template");
+            this.element.insertAdjacentElement("afterend", this.stub);
+            this.target.appendChild(this.element);
+        }
+        if (makeSiblingsInert) {
+            this._makeSiblingsInert();
+        }
+        this.deletionObserver = new MutationObserver(this._deletionObserverCallback.bind(this));
+        this.deletionObserver.observe(document.documentElement, { childList: true, subtree: true });
+        this.isActive = true;
     }
-    this.deletionObserver = new MutationObserver(this._deletionObserverCallback.bind(this));
-    this.deletionObserver.observe(document.documentElement, { childList: true, subtree: true });
-    this.isActive = true;
-  }
-  resume(delay = 0) {
-    if (!this.isActive) {
-      return;
+    resume(delay = 0) {
+        if (!this.isActive) {
+            return;
+        }
+        this.isActive = false;
+        if (delay) {
+            setTimeout(this._resume.bind(this), delay);
+        }
+        else {
+            this._resume();
+        }
     }
-    this.isActive = false;
-    if (delay) {
-      setTimeout(this._resume.bind(this), delay);
+    _resume() {
+        if (!this.element.dataset.reactPortal) {
+            this.stub.insertAdjacentElement("beforebegin", this.element);
+            this.stub.remove();
+        }
+        this._removeInertFromSiblings();
+        this.deletionObserver.disconnect();
     }
-    else {
-      this._resume();
+    _remove() {
+        var _a, _b;
+        (_a = this.element) === null || _a === void 0 ? void 0 : _a.remove();
+        (_b = this.stub) === null || _b === void 0 ? void 0 : _b.remove();
+        this._removeInertFromSiblings();
+        this.deletionObserver.disconnect();
     }
-  }
-  _resume() {
-    if (!this.element.dataset.reactPortal) {
-      this.stub.insertAdjacentElement("beforebegin", this.element);
-      this.stub.remove();
+    _makeSiblingsInert() {
+        const siblings = Array.from(this.target.children);
+        siblings.forEach(sibling => {
+            if (sibling !== this.element) {
+                sibling.dataset.duetTeleportId = (sibling.dataset.duetTeleportId || "") + this.teleportId;
+                sibling.inert = true;
+            }
+        });
+    }
+    _removeInertFromSiblings() {
+        const siblings = Array.from(this.target.children);
+        siblings.forEach(sibling => {
+            var _a;
+            if ((_a = sibling.dataset.duetTeleportId) === null || _a === void 0 ? void 0 : _a.includes(this.teleportId)) {
+                sibling.dataset.duetTeleportId = sibling.dataset.duetTeleportId.replace(this.teleportId, "");
+                if (sibling.dataset.duetTeleportId === "") {
+                    delete sibling.dataset.duetTeleportId;
+                    sibling.inert = false;
+                }
+            }
+        });
+    }
+    /**
+     * If the teleported element or its component (observed via stub) is removed from DOM, clean up the teleport.
+     */
+    _deletionObserverCallback(mutationList) {
+        mutationList.forEach(mutation => {
+            if (Array.from(mutation.removedNodes).includes(this.element) ||
+                Array.from(mutation.removedNodes).some(n => n.contains(this.stub))) {
+                this._remove();
+            }
+        });
     }
-    this._removeInertFromSiblings();
-    this.deletionObserver.disconnect();
-  }
-  _remove() {
-    var _a, _b;
-    (_a = this.element) === null || _a === void 0 ? void 0 : _a.remove();
-    (_b = this.stub) === null || _b === void 0 ? void 0 : _b.remove();
-    this._removeInertFromSiblings();
-    this.deletionObserver.disconnect();
-  }
-  _makeSiblingsInert() {
-    const siblings = Array.from(this.target.children);
-    siblings.forEach(sibling => {
-      if (sibling !== this.element) {
-        sibling.dataset.duetTeleportId = (sibling.dataset.duetTeleportId || "") + this.teleportId;
-        sibling.inert = true;
-      }
-    });
-  }
-  _removeInertFromSiblings() {
-    const siblings = Array.from(this.target.children);
-    siblings.forEach(sibling => {
-      var _a;
-      if ((_a = sibling.dataset.duetTeleportId) === null || _a === void 0 ? void 0 : _a.includes(this.teleportId)) {
-        sibling.dataset.duetTeleportId = sibling.dataset.duetTeleportId.replace(this.teleportId, "");
-        if (sibling.dataset.duetTeleportId === "") {
-          delete sibling.dataset.duetTeleportId;
-          sibling.inert = false;
-        }
-      }
-    });
-  }
-  /**
-   * If the teleported element or its component (observed via stub) is removed from DOM, clean up the teleport.
-   */
-  _deletionObserverCallback(mutationList) {
-    mutationList.forEach(mutation => {
-      if (Array.from(mutation.removedNodes).includes(this.element) ||
-        Array.from(mutation.removedNodes).some(n => n.contains(this.stub))) {
-        this._remove();
-      }
-    });
-  }
 }

package/lib/collection/utils/template-utils.js

@@ -11,23 +11,23 @@
  *    // Logs 'Bryan is now the king of Scotland!'
  */
 export const generateTemplateFn = (function () {
-  const cache = {};
-  function generateTemplate(template) {
-    if (typeof template !== "string") {
-      template = template.outerHTML;
+    const cache = {};
+    function generateTemplate(template) {
+        if (typeof template !== "string") {
+            template = template.outerHTML;
+        }
+        let fn = cache[template];
+        if (!fn) {
+            // Replace ${expressions} (etc) with ${map.expressions}.
+            const sanitized = template
+                .replace(/\$\{([\s]*[^;\s\{]+[\s]*)\}/g, function (_, match) {
+                return `\$\{map.${match.trim()}\}`;
+            })
+                // Afterwards, replace anything that's not ${map.expressions}' (etc) with a blank string.
+                .replace(/(\$\{(?!map\.)[^}]+\})/g, "");
+            fn = Function("map", `return \`${sanitized}\``);
+        }
+        return fn;
     }
-    let fn = cache[template];
-    if (!fn) {
-      // Replace ${expressions} (etc) with ${map.expressions}.
-      const sanitized = template
-        .replace(/\$\{([\s]*[^;\s\{]+[\s]*)\}/g, function (_, match) {
-        return `\$\{map.${match.trim()}\}`;
-      })
-        // Afterwards, replace anything that's not ${map.expressions}' (etc) with a blank string.
-        .replace(/(\$\{(?!map\.)[^}]+\})/g, "");
-      fn = Function("map", `return \`${sanitized}\``);
-    }
-    return fn;
-  }
-  return generateTemplate;
+    return generateTemplate;
 })();