@stimulus-library/mixins 1.3.0 → 1.4.0

package/dist/install_class_methods.js

@@ -21,7 +21,6 @@ function addMethodsForClassDefinition(controller, name) {
     Object.assign(controller, methods);
 }
 export function installClassMethods(controller) {
-    // @ts-ignore
     const classes = controller.constructor.classes || [];
     classes.forEach((classDefinition) => addMethodsForClassDefinition(controller, classDefinition));
 }

package/dist/use_dirty_form_tracking.d.ts

@@ -7,4 +7,13 @@ export declare function useDirtyFormTracking(controller: Controller, form: HTMLF
     restore: () => void;
     teardown: () => void;
 };
+export declare function getElementValue(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): boolean | string;
+export declare function getMultiSelectLoadValues(element: HTMLSelectElement): string[];
+export declare function getMultiSelectValues(element: HTMLSelectElement): string[];
+export declare function getElementLoadValue(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): boolean | string;
+export declare function elementHasCachedLoadValue(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): boolean;
+export declare function isElementDirty(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): boolean;
+export declare function restoreElementFromLoadValue(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): void;
+export declare function restoreMultiSelect(element: HTMLSelectElement, cacheValue: string): void;
+export declare function cacheLoadValues(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): void;
 export declare function isDirty(element: HTMLElement): boolean;

package/dist/use_dirty_form_tracking.js

@@ -60,7 +60,34 @@ export function useDirtyFormTracking(controller, form) {
         teardown,
     };
 }
-function getElementValue(element) {
+function checkDirty(element) {
+    var _a;
+    if (isHTMLInputElement(element) && element.type == "radio") {
+        getOtherRadiosInGroup(element).forEach((radio) => radio.removeAttribute("data-dirty"));
+    }
+    if (isElementDirty(element)) {
+        element.setAttribute("data-dirty", "true");
+        (_a = element.form) === null || _a === void 0 ? void 0 : _a.setAttribute("data-dirty", "true");
+        element.dispatchEvent(new CustomEvent("input-dirtied", {
+            bubbles: true,
+            cancelable: true,
+            detail: {
+                target: element,
+            },
+        }));
+    }
+    else {
+        element.removeAttribute("data-dirty");
+        element.dispatchEvent(new CustomEvent("input-cleaned", {
+            bubbles: true,
+            cancelable: true,
+            detail: {
+                target: element,
+            },
+        }));
+    }
+}
+export function getElementValue(element) {
     if (isElementCheckable(element)) {
         return element.checked;
     }
@@ -71,16 +98,16 @@ function getElementValue(element) {
         return element.value;
     }
 }
-function getMultiSelectLoadValues(element) {
+export function getMultiSelectLoadValues(element) {
     let options = Array.from(element.options);
     options = options.filter(option => option.defaultSelected);
     return options.map(option => option.value);
 }
-function getMultiSelectValues(element) {
+export function getMultiSelectValues(element) {
     let options = Array.from(element.selectedOptions);
     return options.map(option => option.value);
 }
-function getElementLoadValue(element) {
+export function getElementLoadValue(element) {
     const value = element.getAttribute(CACHE_ATTR_NAME);
     if (isElementCheckable(element)) {
         return value == null ? element.defaultChecked : value == "true";
@@ -101,39 +128,13 @@ function getElementLoadValue(element) {
     }
     return value;
 }
-function elementHasCachedLoadValue(element) {
+export function elementHasCachedLoadValue(element) {
     return element.hasAttribute(CACHE_ATTR_NAME);
 }
-function checkDirty(element) {
-    if (isHTMLInputElement(element) && element.type == "radio") {
-        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", {
-            bubbles: true,
-            cancelable: true,
-            detail: {
-                target: element,
-            },
-        }));
-    }
-    else {
-        element.removeAttribute("data-dirty");
-        element.dispatchEvent(new CustomEvent("input-cleaned", {
-            bubbles: true,
-            cancelable: true,
-            detail: {
-                target: element,
-            },
-        }));
-    }
-}
-function isElementDirty(element) {
+export function isElementDirty(element) {
     return getElementValue(element) !== getElementLoadValue(element);
 }
-function restoreElementFromLoadValue(element) {
+export function restoreElementFromLoadValue(element) {
     const cacheValue = element.getAttribute(CACHE_ATTR_NAME);
     if (isElementCheckable(element)) {
         element.setAttribute(CACHE_ATTR_NAME, element.checked.toString());
@@ -157,13 +158,15 @@ function restoreElementFromLoadValue(element) {
     }
     checkDirty(element);
 }
-function restoreMultiSelect(element, cacheValue) {
+export function restoreMultiSelect(element, cacheValue) {
     let selectedOptions = JSON.parse(cacheValue);
     Array.from(element.options).forEach((option) => option.selected = selectedOptions.includes(option.value));
 }
-function cacheLoadValues(element) {
-    if (!elementHasCachedLoadValue(element) && isElementCheckable(element)) {
-        element.setAttribute(CACHE_ATTR_NAME, element.checked.toString());
+export function cacheLoadValues(element) {
+    if (isElementCheckable(element)) {
+        if (!elementHasCachedLoadValue(element)) {
+            element.setAttribute(CACHE_ATTR_NAME, element.checked.toString());
+        }
     }
     else if (isHTMLSelectElement(element) && element.multiple) {
         element.setAttribute(CACHE_ATTR_NAME, JSON.stringify(getMultiSelectLoadValues(element)));

package/dist/use_event_bus.js

@@ -2,7 +2,7 @@ import { debounce, EventBus, wrapArray } from "@stimulus-library/utilities";
 import { useMixin } from "./use_mixin";
 export function useEventBus(controller, eventNameOrNames, handler, opts) {
     const options = opts;
-    if (options?.debounce) {
+    if (options === null || options === void 0 ? void 0 : options.debounce) {
         handler = debounce(handler.bind(controller), options.debounce);
         delete options.debounce;
     }

package/dist/use_event_listener.js

@@ -1,7 +1,7 @@
 import { debounce, wrapArray } from "@stimulus-library/utilities";
 import { useMixin } from "./use_mixin";
 export function useEventListener(controller, element, eventNameOrNames, handler, opts) {
-    if (opts?.debounce) {
+    if (opts === null || opts === void 0 ? void 0 : opts.debounce) {
         handler = debounce(handler.bind(controller), opts.debounce);
         delete opts.debounce;
     }

package/dist/use_geolocation.js

@@ -1,17 +1,14 @@
 import { reactive } from "@stimulus-library/utilities";
 import { useMixin } from "./use_mixin";
 export function useGeolocation(controller, options = {}, update, error) {
-    // Ensure passed functions are bound to the correct controller scope
     if (update) {
         update = update.bind(controller);
     }
     if (error) {
         error = error.bind(controller);
     }
-    // Default options to pass to the navigator.geolocation.watchPosition() method
     const { enableHighAccuracy = true, maximumAge = 30000, timeout = 27000, } = options;
     const isSupported = navigator && "geolocation" in navigator;
-    // Create a reactive object to store the geolocation data
     const values = reactive({
         locatedAt: null,
         error: null,
@@ -34,18 +31,14 @@ export function useGeolocation(controller, options = {}, update, error) {
     const setup = () => {
         if (isSupported) {
             watcher = navigator.geolocation.watchPosition((position) => {
-                // Update reactive values
                 values.locatedAt = position.timestamp;
                 values.coords = position.coords;
                 values.error = null;
-                // Fire user callback if provided
                 if (update) {
                     update(position);
                 }
             }, (err) => {
-                // Update reactive values
                 values.error = err;
-                // Fire user callback if provided
                 if (error) {
                     error(err);
                 }

package/dist/use_intersection.js

@@ -3,11 +3,11 @@ export function useIntersectionObserver(controller, handler, options) {
     handler = handler.bind(controller);
     let observer = new IntersectionObserver(handler, options);
     const teardown = () => {
-        observer?.disconnect();
+        observer === null || observer === void 0 ? void 0 : observer.disconnect();
         observer = null;
     };
-    const observe = (element) => observer?.observe(element);
-    const unobserve = (element) => observer?.unobserve(element);
+    const observe = (element) => observer === null || observer === void 0 ? void 0 : observer.observe(element);
+    const unobserve = (element) => observer === null || observer === void 0 ? void 0 : observer.unobserve(element);
     return {
         observer,
         teardown,
@@ -22,7 +22,7 @@ export function useIntersection(controller, element, appear, disappear, options)
     if (disappear) {
         disappear = disappear.bind(controller);
     }
-    const opts = options ?? {};
+    const opts = options !== null && options !== void 0 ? options : {};
     const processEntries = (entries) => {
         entries.forEach((entry) => {
             if (entry.isIntersecting) {

package/dist/use_localstorage.js

@@ -9,7 +9,6 @@ export const StorageSerializers = {
     object: {
         deserialize: (v) => JSON.parse(v),
         serialize: (v) => {
-            // Change events are triggered with a string value
             if (typeof v === "string") {
                 return v;
             }
@@ -55,6 +54,7 @@ export const StorageSerializers = {
     },
 };
 export function useLocalStorage(controller, key, defaultValue, opts) {
+    var _a;
     let type;
     const optsMergedWithDefaults = {
         onChange: null,
@@ -89,7 +89,7 @@ export function useLocalStorage(controller, key, defaultValue, opts) {
     else {
         type = "any";
     }
-    const onChange = optsMergedWithDefaults.onChange?.bind(controller);
+    const onChange = (_a = optsMergedWithDefaults.onChange) === null || _a === void 0 ? void 0 : _a.bind(controller);
     const data = reactive({
         value: defaultValue,
     });

package/dist/use_trix_modifiers.js

@@ -3,7 +3,6 @@ import { Controller } from "@hotwired/stimulus";
 export class TrixComposableController extends Controller {
 }
 export function useTrixModifiers(controller) {
-    // keep a copy of the lifecycle function of the controller
     const controllerDisconnect = controller.disconnect.bind(controller);
     let observing = false;
     const observerCallback = (entries, observer) => {
@@ -28,17 +27,14 @@ export function useTrixModifiers(controller) {
         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;
             observer.observe(editorParent, { childList: true });
             return;
         }
         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>");
         }
         else {
-            // Do not need MutationObserver, all elements are present and correct
             observer.disconnect();
         }
         controllerMethod(controller, "install").call(controller, { toolbar, editor });

package/package.json

@@ -9,7 +9,7 @@
     "ruby on rails",
     "ruby-on-rails"
   ],
-  "version": "1.3.0",
+  "version": "1.4.0",
   "license": "MIT",
   "author": {
     "name": "Sub-Xaero",
@@ -37,12 +37,12 @@
   },
   "dependencies": {
     "@hotwired/stimulus": "^3.0.0",
-    "@stimulus-library/utilities": "^1.3.0"
+    "@stimulus-library/utilities": "^1.4.0"
   },
   "devDependencies": {
     "@types/chai": "^5.0.1",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^22.13.17",
+    "@types/node": "^24.0.7",
     "@types/sinon": "^17.0.1",
     "@types/sinon-chai": "^4.0.0",
     "agadoo": "^3.0.0",
@@ -51,12 +51,12 @@
     "lerna": "^8.0.0",
     "mocha": "^11.1.0",
     "rimraf": "^6.0.1",
-    "sinon": "^20.0.0",
+    "sinon": "^21.0.0",
     "sinon-chai": "^4.0.0",
     "standard-version": "^9.5.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2",
-    "vite": "^6.2.4"
+    "vite": "^7.0.2"
   },
-  "gitHead": "3b4c2c325aeffcfaef66e6a06ff68f00049289de"
+  "gitHead": "81299cf017b9c43a6e1e3bf85dec0d649f2efce4"
 }