@stimulus-library/mixins 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-export * from './install_class_methods';
-export * from './use_click_outside';
-export * from './use_dirty_form_tracking';
-export * from './use_event_bus';
-export * from './use_event_listener';
-export * from './use_fullscreen';
-export * from './use_geolocation';
-export * from './use_hover';
-export * from './use_injected_html';
-export * from './use_intersection';
-export * from './use_interval';
-export * from './use_localstorage';
-export * from './use_mutation_observer';
-export * from './use_resize_observer';
-export * from './use_temporary_content';
-export * from './use_text_selection';
-export * from './use_timeout';
-export * from './use_trix_modifiers';
+export * from "./install_class_methods";
+export * from "./use_click_outside";
+export * from "./use_dirty_form_tracking";
+export * from "./use_event_bus";
+export * from "./use_event_listener";
+export * from "./use_fullscreen";
+export * from "./use_geolocation";
+export * from "./use_hover";
+export * from "./use_injected_html";
+export * from "./use_intersection";
+export * from "./use_interval";
+export * from "./use_localstorage";
+export * from "./use_mutation_observer";
+export * from "./use_resize_observer";
+export * from "./use_temporary_content";
+export * from "./use_text_selection";
+export * from "./use_timeout";
+export * from "./use_trix_modifiers";

package/dist/index.js

@@ -1,18 +1,18 @@
-export * from './install_class_methods';
-export * from './use_click_outside';
-export * from './use_dirty_form_tracking';
-export * from './use_event_bus';
-export * from './use_event_listener';
-export * from './use_fullscreen';
-export * from './use_geolocation';
-export * from './use_hover';
-export * from './use_injected_html';
-export * from './use_intersection';
-export * from './use_interval';
-export * from './use_localstorage';
-export * from './use_mutation_observer';
-export * from './use_resize_observer';
-export * from './use_temporary_content';
-export * from './use_text_selection';
-export * from './use_timeout';
-export * from './use_trix_modifiers';
+export * from "./install_class_methods";
+export * from "./use_click_outside";
+export * from "./use_dirty_form_tracking";
+export * from "./use_event_bus";
+export * from "./use_event_listener";
+export * from "./use_fullscreen";
+export * from "./use_geolocation";
+export * from "./use_hover";
+export * from "./use_injected_html";
+export * from "./use_intersection";
+export * from "./use_interval";
+export * from "./use_localstorage";
+export * from "./use_mutation_observer";
+export * from "./use_resize_observer";
+export * from "./use_temporary_content";
+export * from "./use_text_selection";
+export * from "./use_timeout";
+export * from "./use_trix_modifiers";

package/dist/install_class_methods.js

@@ -3,17 +3,17 @@ import { controllerMethod, pascalCase } from "@stimulus-library/utilities";
 export class InstallClassMethodComposableController extends Controller {
 }
 function addMethodsForClassDefinition(controller, name) {
-    let defaultElement = controller.element;
-    let hasClass = () => controller[`has${pascalCase(name)}Class`] == true;
-    let classes = () => controller[`${name}Classes`];
-    let defaultClasses = () => controllerMethod(controller, `default${pascalCase(name)}Classes`).call(controller) || [];
-    let classOrDefault = () => hasClass() ? classes() : defaultClasses();
+    const defaultElement = controller.element;
+    const hasClass = () => controller[`has${pascalCase(name)}Class`] == true;
+    const classes = () => controller[`${name}Classes`];
+    const defaultClasses = () => controllerMethod(controller, `default${pascalCase(name)}Classes`).call(controller) || [];
+    const classOrDefault = () => hasClass() ? classes() : defaultClasses();
     if (controller[`${name}Classes`] == undefined) {
         Object.defineProperty(controller, `${name}Classes`, {
-            get: () => hasClass() ? controller[`${name}Class`].split(' ') : defaultClasses(),
+            get: () => hasClass() ? controller[`${name}Class`].split(" ") : defaultClasses(),
         });
     }
-    let methods = {
+    const methods = {
         [`add${pascalCase(name)}Classes`]: (element = defaultElement) => element.classList.add(...classOrDefault()),
         [`remove${pascalCase(name)}Classes`]: (element = defaultElement) => element.classList.remove(...classOrDefault()),
         [`${name}ClassesPresent`]: (element = defaultElement) => classOrDefault().every((klass) => element.classList.contains(klass)),
@@ -22,6 +22,6 @@ function addMethodsForClassDefinition(controller, name) {
 }
 export function installClassMethods(controller) {
     // @ts-ignore
-    let classes = controller.constructor.classes || [];
+    const classes = controller.constructor.classes || [];
     classes.forEach((classDefinition) => addMethodsForClassDefinition(controller, classDefinition));
 }

package/dist/use_click_outside.js

@@ -9,7 +9,7 @@ export function useClickOutside(controller, element, callback) {
         }
         callback(event);
     };
-    let { teardown } = useEventListener(controller, window, ["click", "touchend"], handler);
+    const { teardown } = useEventListener(controller, window, ["click", "touchend"], handler);
     useMixin(controller, () => void 0, teardown);
     return {
         teardown,

package/dist/use_dirty_form_tracking.js

@@ -3,12 +3,12 @@ import { getOtherRadiosInGroup, isElementCheckable, isHTMLInputElement, isHTMLSe
 import { useEventListener } from "./use_event_listener";
 const CACHE_ATTR_NAME = "data-detect-dirty-load-value";
 export function useDirtyInputTracking(controller, element) {
-    let setup = () => {
+    const setup = () => {
         cacheLoadValues(element);
         checkDirty(element);
         useEventListener(controller, element, ["input", "change"], () => checkDirty(element), { debounce: 10 });
     };
-    let teardown = () => {
+    const teardown = () => {
     };
     useMixin(controller, setup, teardown);
     return {
@@ -17,17 +17,17 @@ export function useDirtyInputTracking(controller, element) {
     };
 }
 export function useDirtyFormTracking(controller, form) {
-    let teardowns = [];
-    let restores = [];
-    let setup = () => {
+    const teardowns = [];
+    const restores = [];
+    const setup = () => {
         form.querySelectorAll("input, select, textarea").forEach((element) => {
-            let functions = useDirtyInputTracking(controller, element);
+            const functions = useDirtyInputTracking(controller, element);
             teardowns.push(functions.teardown);
             restores.push(functions.restore);
         });
-        useEventListener(controller, form, 'input-dirtied', () => {
-            form.setAttribute('data-dirty', 'true');
-            form.dispatchEvent(new CustomEvent('form-dirtied', {
+        useEventListener(controller, form, "input-dirtied", () => {
+            form.setAttribute("data-dirty", "true");
+            form.dispatchEvent(new CustomEvent("form-dirtied", {
                 bubbles: true,
                 cancelable: true,
                 detail: {
@@ -35,10 +35,10 @@ export function useDirtyFormTracking(controller, form) {
                 },
             }));
         });
-        useEventListener(controller, form, 'input-cleaned', () => {
-            if (form.querySelectorAll('[data-dirty="true"]').length === 0) {
-                form.removeAttribute('data-dirty');
-                form.dispatchEvent(new CustomEvent('form-cleaned', {
+        useEventListener(controller, form, "input-cleaned", () => {
+            if (form.querySelectorAll("[data-dirty=\"true\"]").length === 0) {
+                form.removeAttribute("data-dirty");
+                form.dispatchEvent(new CustomEvent("form-cleaned", {
                     bubbles: true,
                     cancelable: true,
                     detail: {
@@ -48,10 +48,10 @@ export function useDirtyFormTracking(controller, form) {
             }
         });
     };
-    let teardown = () => {
+    const teardown = () => {
         teardowns.forEach((teardown) => teardown());
     };
-    let restore = () => {
+    const restore = () => {
         restores.forEach((restore) => restore());
     };
     useMixin(controller, setup, teardown);
@@ -64,12 +64,12 @@ function getElementValue(element) {
     return isElementCheckable(element) ? element.checked : element.value;
 }
 function getElementLoadValue(element) {
-    let value = element.getAttribute(CACHE_ATTR_NAME);
+    const value = element.getAttribute(CACHE_ATTR_NAME);
     if (isElementCheckable(element)) {
         return value == null ? element.defaultChecked : value == "true";
     }
     else if (isHTMLSelectElement(element)) {
-        let options = Array.from(element.options);
+        const options = Array.from(element.options);
         options.forEach((option) => {
             if (option.defaultSelected) {
                 return option.value;
@@ -86,12 +86,12 @@ function elementHasCachedLoadValue(element) {
 }
 function checkDirty(element) {
     if (isHTMLInputElement(element) && element.type == "radio") {
-        getOtherRadiosInGroup(element).forEach((radio) => radio.removeAttribute('data-dirty'));
+        getOtherRadiosInGroup(element).forEach((radio) => radio.removeAttribute("data-dirty"));
     }
     if (isElementDirty(element)) {
-        element.setAttribute('data-dirty', "true");
-        element.form?.setAttribute('data-dirty', "true");
-        element.dispatchEvent(new CustomEvent('input-dirtied', {
+        element.setAttribute("data-dirty", "true");
+        element.form?.setAttribute("data-dirty", "true");
+        element.dispatchEvent(new CustomEvent("input-dirtied", {
             bubbles: true,
             cancelable: true,
             detail: {
@@ -100,8 +100,8 @@ function checkDirty(element) {
         }));
     }
     else {
-        element.removeAttribute('data-dirty');
-        element.dispatchEvent(new CustomEvent('input-cleaned', {
+        element.removeAttribute("data-dirty");
+        element.dispatchEvent(new CustomEvent("input-cleaned", {
             bubbles: true,
             cancelable: true,
             detail: {
@@ -114,14 +114,14 @@ function isElementDirty(element) {
     return getElementValue(element) !== getElementLoadValue(element);
 }
 function restoreElementFromLoadValue(element) {
-    let cacheValue = element.getAttribute(CACHE_ATTR_NAME);
+    const cacheValue = element.getAttribute(CACHE_ATTR_NAME);
     if (isElementCheckable(element)) {
         element.setAttribute(CACHE_ATTR_NAME, element.checked.toString());
         element.checked = cacheValue == null ? element.defaultChecked : cacheValue == "true";
     }
     else if (isHTMLSelectElement(element)) {
         if (cacheValue == null) {
-            let options = Array.from(element.options);
+            const options = Array.from(element.options);
             options.forEach((option) => {
                 if (option.defaultSelected) {
                     element.value = option.value;

package/dist/use_event_bus.js

@@ -1,7 +1,7 @@
 import { debounce, EventBus, wrapArray } from "@stimulus-library/utilities";
 import { useMixin } from "./use_mixin";
 export function useEventBus(controller, eventNameOrNames, handler, opts) {
-    let options = opts;
+    const options = opts;
     if (options?.debounce) {
         handler = debounce(handler.bind(controller), options.debounce);
         delete options.debounce;
@@ -9,9 +9,9 @@ export function useEventBus(controller, eventNameOrNames, handler, opts) {
     else {
         handler = handler.bind(controller);
     }
-    let eventNames = wrapArray(eventNameOrNames);
-    let setup = () => eventNames.forEach(eventName => EventBus.on(eventName, handler));
-    let teardown = () => eventNames.forEach(eventName => EventBus.off(eventName, handler));
+    const eventNames = wrapArray(eventNameOrNames);
+    const setup = () => eventNames.forEach(eventName => EventBus.on(eventName, handler));
+    const teardown = () => eventNames.forEach(eventName => EventBus.off(eventName, handler));
     useMixin(controller, setup, teardown);
     return { setup, teardown };
 }

package/dist/use_event_listener.js

@@ -8,9 +8,9 @@ export function useEventListener(controller, element, eventNameOrNames, handler,
     else {
         handler = handler.bind(controller);
     }
-    let eventNames = wrapArray(eventNameOrNames);
-    let setup = () => eventNames.forEach(eventName => element.addEventListener(eventName, handler, opts));
-    let teardown = () => eventNames.forEach(eventName => element.removeEventListener(eventName, handler));
+    const eventNames = wrapArray(eventNameOrNames);
+    const setup = () => eventNames.forEach(eventName => element.addEventListener(eventName, handler, opts));
+    const teardown = () => eventNames.forEach(eventName => element.removeEventListener(eventName, handler));
     useMixin(controller, setup, teardown);
     return { setup, teardown };
 }
@@ -18,9 +18,9 @@ export function useEventListeners(controller, element, eventNameOrNames, handler
     return useEventListener(controller, element, eventNameOrNames, handler, opts);
 }
 export function useCollectionEventListener(controller, elements, eventNameOrNames, handler, opts) {
-    let handlers = [];
+    const handlers = [];
     elements.forEach(el => {
-        let { setup, teardown } = useEventListener(controller, el, eventNameOrNames, handler, opts);
+        const { setup, teardown } = useEventListener(controller, el, eventNameOrNames, handler, opts);
         handlers.push({ setup, teardown });
     });
     return [

package/dist/use_fullscreen.js

@@ -1,12 +1,12 @@
 import { useMixin } from "./use_mixin";
 export function useFullscreen(controller, el) {
-    let element = el || document.documentElement;
+    const element = el || document.documentElement;
     let fullscreenOpen = document.fullscreenElement !== null;
     const updateFullscreenState = () => fullscreenOpen = document.fullscreenElement !== null;
     const isFullscreen = () => fullscreenOpen;
     const toggle = async () => fullscreenOpen ? await exit() : await enter();
-    let setup = () => document.addEventListener('fullscreenchange', updateFullscreenState);
-    let teardown = () => document.removeEventListener('fullscreenchange', updateFullscreenState);
+    const setup = () => document.addEventListener("fullscreenchange", updateFullscreenState);
+    const teardown = () => document.removeEventListener("fullscreenchange", updateFullscreenState);
     const exit = async () => {
         if (document.exitFullscreen) {
             fullscreenOpen = false;

package/dist/use_geolocation.js

@@ -10,7 +10,7 @@ export function useGeolocation(controller, options = {}, update, error) {
     }
     // Default options to pass to the navigator.geolocation.watchPosition() method
     const { enableHighAccuracy = true, maximumAge = 30000, timeout = 27000, } = options;
-    const isSupported = navigator && 'geolocation' in navigator;
+    const isSupported = navigator && "geolocation" in navigator;
     // Create a reactive object to store the geolocation data
     const values = reactive({
         locatedAt: null,
@@ -31,7 +31,7 @@ export function useGeolocation(controller, options = {}, update, error) {
             }
         },
     });
-    let setup = () => {
+    const setup = () => {
         if (isSupported) {
             watcher = navigator.geolocation.watchPosition((position) => {
                 // Update reactive values

package/dist/use_hover.js

@@ -5,16 +5,16 @@ export function useHover(controller, element, enter, leave) {
     let teardownLeave = null;
     if (enter) {
         enter = enter.bind(controller);
-        let { teardown: _teardownEnter } = useEventListener(controller, element, "mouseenter", enter);
+        const { teardown: _teardownEnter } = useEventListener(controller, element, "mouseenter", enter);
         teardownEnter = _teardownEnter;
     }
     if (leave) {
         leave = leave.bind(controller);
-        let { teardown: _teardownLeave } = useEventListener(controller, element, "mouseleave", leave);
+        const { teardown: _teardownLeave } = useEventListener(controller, element, "mouseleave", leave);
         teardownLeave = _teardownLeave;
     }
-    let setup = () => void 0;
-    let teardown = () => {
+    const setup = () => void 0;
+    const teardown = () => {
         if (teardownEnter) {
             teardownEnter();
         }

package/dist/use_injected_html.js

@@ -1,13 +1,13 @@
 import { useMixin } from "./use_mixin";
 export function useInjectedFragment(controller, targetElement, insertPosition, fragment, options = {}) {
-    let nodes = Array.from(fragment.childNodes);
-    let setup = () => {
-        let parent = targetElement.parentElement;
+    const nodes = Array.from(fragment.childNodes);
+    const setup = () => {
+        const parent = targetElement.parentElement;
         if (["beforebegin", "afterend"].includes(insertPosition) && parent == null) {
             throw new Error("Cannot insert beforebegin into a node with no parent");
         }
         switch (insertPosition) {
-            case 'beforeend':
+            case "beforeend":
                 targetElement.append(fragment);
                 break;
             case "afterbegin":
@@ -21,7 +21,7 @@ export function useInjectedFragment(controller, targetElement, insertPosition, f
                 break;
         }
     };
-    let teardown = options.cleanup ? () => nodes.forEach(node => node.remove()) : () => void 0;
+    const teardown = options.cleanup ? () => nodes.forEach(node => node.remove()) : () => void 0;
     useMixin(controller, setup, teardown);
     return [nodes, teardown];
 }
@@ -32,6 +32,6 @@ export function useInjectedHTML(controller, targetElement, insertPosition, html,
 export function useInjectedElement(controller, targetElement, insertPosition, element, options = {}) {
     const fragment = new DocumentFragment();
     fragment.append(element);
-    let [nodes, teardown] = useInjectedFragment(controller, targetElement, insertPosition, fragment, options);
+    const [nodes, teardown] = useInjectedFragment(controller, targetElement, insertPosition, fragment, options);
     return [nodes[0], teardown];
 }

package/dist/use_intersection.js

@@ -2,12 +2,12 @@ import { useMixin } from "./use_mixin";
 export function useIntersectionObserver(controller, handler, options) {
     handler = handler.bind(controller);
     let observer = new IntersectionObserver(handler, options);
-    let teardown = () => {
+    const teardown = () => {
         observer?.disconnect();
         observer = null;
     };
-    let observe = (element) => observer?.observe(element);
-    let unobserve = (element) => observer?.unobserve(element);
+    const observe = (element) => observer?.observe(element);
+    const unobserve = (element) => observer?.unobserve(element);
     return {
         observer,
         teardown,
@@ -22,8 +22,8 @@ export function useIntersection(controller, element, appear, disappear, options)
     if (disappear) {
         disappear = disappear.bind(controller);
     }
-    let opts = options ?? {};
-    let processEntries = (entries) => {
+    const opts = options ?? {};
+    const processEntries = (entries) => {
         entries.forEach((entry) => {
             if (entry.isIntersecting) {
                 appear && appear(entry);
@@ -33,8 +33,8 @@ export function useIntersection(controller, element, appear, disappear, options)
             }
         });
     };
-    let { observer, observe, unobserve, teardown } = useIntersectionObserver(controller, processEntries, opts);
-    let setup = () => observe(element);
+    const { observer, observe, unobserve, teardown } = useIntersectionObserver(controller, processEntries, opts);
+    const setup = () => observe(element);
     useMixin(controller, setup, teardown);
     return {
         observer,

package/dist/use_interval.js

@@ -2,8 +2,8 @@ import { useMixin } from "./use_mixin";
 export function useInterval(controller, handler, interval) {
     handler = handler.bind(controller);
     let intervalHandle = null;
-    let setup = () => intervalHandle = setInterval(handler, interval);
-    let teardown = () => {
+    const setup = () => intervalHandle = setInterval(handler, interval);
+    const teardown = () => {
         if (intervalHandle !== null) {
             clearInterval(intervalHandle);
         }

package/dist/use_localstorage.js

@@ -56,12 +56,12 @@ export const StorageSerializers = {
 };
 export function useLocalStorage(controller, key, defaultValue, opts) {
     let type;
-    let optsMergedWithDefaults = {
+    const optsMergedWithDefaults = {
         onChange: null,
         writeDefaults: true,
         ...opts,
     };
-    let { writeDefaults } = optsMergedWithDefaults;
+    const { writeDefaults } = optsMergedWithDefaults;
     if (defaultValue === null || defaultValue === undefined) {
         type = "any";
     }
@@ -89,11 +89,11 @@ export function useLocalStorage(controller, key, defaultValue, opts) {
     else {
         type = "any";
     }
-    let onChange = optsMergedWithDefaults.onChange?.bind(controller);
-    let data = reactive({
+    const onChange = optsMergedWithDefaults.onChange?.bind(controller);
+    const data = reactive({
         value: defaultValue,
     });
-    let storage = localStorage;
+    const storage = localStorage;
     const serializer = StorageSerializers[type];
     const read = () => {
         const rawValue = storage.getItem(key);
@@ -121,13 +121,12 @@ export function useLocalStorage(controller, key, defaultValue, opts) {
         return data.value;
     };
     const isEmpty = () => {
-        let rawValue = storage.getItem(key);
+        const rawValue = storage.getItem(key);
         return serializer.isEmpty(rawValue);
     };
     read();
     useEventListener(controller, window, "storage", (event) => {
         if (event.key === key) {
-            console.log(event.newValue, event.oldValue);
             write(event.newValue);
         }
     });

package/dist/use_mutation_observer.js

@@ -1,9 +1,9 @@
 import { useMixin } from "./use_mixin";
 export function useMutationObserver(controller, element, handler, options) {
     handler = handler.bind(controller);
-    let observer = new MutationObserver(handler);
-    let setup = () => observer.observe(element, options);
-    let teardown = () => observer.disconnect();
+    const observer = new MutationObserver(handler);
+    const setup = () => observer.observe(element, options);
+    const teardown = () => observer.disconnect();
     useMixin(controller, setup, teardown);
     return teardown;
 }

package/dist/use_resize_observer.js

@@ -1,9 +1,9 @@
 import { useMixin } from "./use_mixin";
 export function useResizeObserver(controller, element, handler, options) {
     handler = handler.bind(controller);
-    let observer = new ResizeObserver(handler);
-    let setup = () => observer.observe(element, options);
-    let teardown = () => observer.disconnect();
+    const observer = new ResizeObserver(handler);
+    const setup = () => observer.observe(element, options);
+    const teardown = () => observer.disconnect();
     useMixin(controller, setup, teardown);
     return teardown;
 }

package/dist/use_temporary_content.js

@@ -14,7 +14,7 @@ export function useTemporaryContent(controller, target, content, timeout, teardo
         return isHTMLInputElement(element) ? element.value : element.innerHTML;
     };
     let cleanupTimeout = () => void 0;
-    let originalText = getContent(target);
+    const originalText = getContent(target);
     const teardown = () => {
         setContent(target, originalText);
         cleanupTimeout();

package/dist/use_text_selection.js

@@ -1,12 +1,12 @@
 import { useEventListener } from "./use_event_listener";
 export function useTextSelection(controller, handler) {
     handler = handler.bind(controller);
-    let onSelectionChange = () => {
-        let selection = window.getSelection();
+    const onSelectionChange = () => {
+        const selection = window.getSelection();
         handler(selection);
     };
-    let { teardown: unwatch } = useEventListener(controller, window.document, 'selectionchange', onSelectionChange);
-    let teardown = () => {
+    const { teardown: unwatch } = useEventListener(controller, window.document, "selectionchange", onSelectionChange);
+    const teardown = () => {
         unwatch();
     };
     return {

package/dist/use_timeout.js

@@ -1,15 +1,16 @@
 import { useMixin } from "./use_mixin";
 export function useTimeout(controller, handler, timeout) {
+    // eslint-disable-next-line prefer-const
     let controllerDisconnect;
     let timeoutHandle = null;
     handler = handler.bind(controller);
-    let newHandler = () => {
+    const newHandler = () => {
         handler();
         timeoutHandle = null;
         Object.assign(controller, { disconnect: controllerDisconnect });
     };
-    let setup = () => timeoutHandle = setTimeout(newHandler, timeout);
-    let teardown = () => {
+    const setup = () => timeoutHandle = setTimeout(newHandler, timeout);
+    const teardown = () => {
         if (timeoutHandle !== null) {
             clearTimeout(timeoutHandle);
             timeoutHandle = null;

package/dist/use_trix_modifiers.js

@@ -6,27 +6,27 @@ export function useTrixModifiers(controller) {
     // keep a copy of the lifecycle function of the controller
     const controllerDisconnect = controller.disconnect.bind(controller);
     let observing = false;
-    let observerCallback = (entries, observer) => {
+    const observerCallback = (entries, observer) => {
         entries.forEach(mutation => {
-            if (mutation.type === 'childList' && Array.from(mutation.addedNodes).some((el) => el.tagName === 'TRIX-TOOLBAR')) {
+            if (mutation.type === "childList" && Array.from(mutation.addedNodes).some((el) => el.tagName === "TRIX-TOOLBAR")) {
                 attemptSetup();
                 observer.disconnect();
             }
         });
     };
-    let pasteHandler = (event) => controllerMethod(controller, 'pasteEvent').call(controller, event);
-    let observer = new MutationObserver(observerCallback);
-    let attemptSetup = () => {
-        if (controller.element.tagName !== 'TRIX-EDITOR') {
-            throw new Error('Expected controller to be mounted on an instance of <trix-editor>');
+    const pasteHandler = (event) => controllerMethod(controller, "pasteEvent").call(controller, event);
+    const observer = new MutationObserver(observerCallback);
+    const attemptSetup = () => {
+        if (controller.element.tagName !== "TRIX-EDITOR") {
+            throw new Error("Expected controller to be mounted on an instance of <trix-editor>");
         }
-        let editor = controller.element;
-        let editorParent = controller.element.parentElement;
+        const editor = controller.element;
+        const editorParent = controller.element.parentElement;
         if (editorParent == null) {
-            throw new Error('Could not traverse DOM tree from <trix-editor>');
+            throw new Error("Could not traverse DOM tree from <trix-editor>");
         }
-        editor.addEventListener('trix-paste', pasteHandler);
-        let toolbar = editorParent.querySelector('trix-toolbar');
+        editor.addEventListener("trix-paste", pasteHandler);
+        const toolbar = editorParent.querySelector("trix-toolbar");
         if (!observing && !toolbar) {
             // toolbar is not in the DOM yet, wait for it to arrive before running setup
             observing = true;
@@ -35,36 +35,36 @@ export function useTrixModifiers(controller) {
         }
         else if (!toolbar) {
             // Fallback, in case this runs twice, or mutation observer logic fails
-            throw new Error('Could not find an instance of <trix-toolbar> that is a sibling of this <trix-editor>');
+            throw new Error("Could not find an instance of <trix-toolbar> that is a sibling of this <trix-editor>");
         }
         else {
             // Do not need MutationObserver, all elements are present and correct
             observer.disconnect();
         }
-        controllerMethod(controller, 'install').call(controller, { toolbar, editor });
+        controllerMethod(controller, "install").call(controller, { toolbar, editor });
     };
-    let teardown = () => {
-        if (controller.element.tagName !== 'TRIX-EDITOR') {
-            throw new Error('Expected controller to be mounted on an instance of <trix-editor>');
+    const teardown = () => {
+        if (controller.element.tagName !== "TRIX-EDITOR") {
+            throw new Error("Expected controller to be mounted on an instance of <trix-editor>");
         }
-        let editor = controller.element;
-        let editorParent = controller.element.parentElement;
+        const editor = controller.element;
+        const editorParent = controller.element.parentElement;
         if (editorParent == null) {
-            throw new Error('Could not traverse DOM tree from <trix-editor>');
+            throw new Error("Could not traverse DOM tree from <trix-editor>");
         }
-        editor.removeEventListener('trix-paste', pasteHandler);
-        let toolbar = editorParent.querySelector('trix-toolbar');
+        editor.removeEventListener("trix-paste", pasteHandler);
+        const toolbar = editorParent.querySelector("trix-toolbar");
         if (!toolbar) {
-            throw new Error('Could not find <trix-toolbar> that is a sibling of this <trix-editor> element');
+            throw new Error("Could not find <trix-toolbar> that is a sibling of this <trix-editor> element");
         }
-        controllerMethod(controller, 'uninstall').call(controller, { toolbar, editor });
+        controllerMethod(controller, "uninstall").call(controller, { toolbar, editor });
     };
     attemptSetup();
     Object.assign(controller, {
         disconnect() {
             observer.disconnect();
             teardown();
-            controllerMethod(controller, 'uninstall').call({ toolbar, editor: controller.element });
+            controllerMethod(controller, "uninstall").call({ toolbar, editor: controller.element });
             controllerDisconnect();
         },
     });

package/package.json

@@ -9,7 +9,7 @@
     "ruby on rails",
     "ruby-on-rails"
   ],
-  "version": "1.0.1",
+  "version": "1.0.3",
   "license": "MIT",
   "author": {
     "name": "Sub-Xaero",
@@ -23,6 +23,7 @@
   "files": [
     "dist"
   ],
+  "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -35,7 +36,7 @@
   },
   "dependencies": {
     "@hotwired/stimulus": "^3.0.0",
-    "@stimulus-library/utilities": "^1.0.1"
+    "@stimulus-library/utilities": "^1.0.3"
   },
   "devDependencies": {
     "@types/chai": "^4.3.5",
@@ -48,12 +49,12 @@
     "lerna": "^7.0.0",
     "mocha": "^10.2.0",
     "rimraf": "^5.0.1",
-    "sinon": "^15.1.0",
+    "sinon": "^16.0.0",
     "sinon-chai": "^3.7.0",
     "standard-version": "^9.5.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.1.3",
     "vite": "^4.1.1"
   },
-  "gitHead": "26a7da01746a2bdf8a2a731b79d37256b789bdc0"
+  "gitHead": "87d6154d0b5ec364033b04d9f469db5143d031eb"
 }