@douglasneuroinformatics/libui 2.0.2 → 2.0.4

package/dist/hooks/useSessionStorage.js

@@ -0,0 +1,99 @@
+import { useCallback, useEffect, useState } from 'react';
+import { isBrowser } from '../utils.js';
+import { useEventCallback } from './useEventCallback.js';
+import { useEventListener } from './useEventListener.js';
+/**
+ * Custom hook that uses session storage to persist state across page reloads.
+ * @template T - The type of the state to be stored in session storage.
+ * @param {string} key - The key under which the value will be stored in session storage.
+ * @param {T | (() => T)} initialValue - The initial value of the state or a function that returns the initial value.
+ * @param {?UseSessionStorageOptions<T>} [options] - Options for customizing the behavior of serialization and deserialization (optional).
+ * @returns {[T, Dispatch<SetStateAction<T>>]} A tuple containing the stored value and a function to set the value.
+ * @public
+ * @example
+ * ```tsx
+ * const [count, setCount] = useSessionStorage('count', 0);
+ * // Access the `count` value and the `setCount` function to update it.
+ * ```
+ */
+export function useSessionStorage(key, initialValue, options = {}) {
+    const { initializeWithValue = true } = options;
+    const serializer = useCallback((value) => {
+        if (options.serializer) {
+            return options.serializer(value);
+        }
+        return JSON.stringify(value);
+    }, [options]);
+    const deserializer = useCallback((value) => {
+        if (options.deserializer) {
+            return options.deserializer(value);
+        }
+        // Support 'undefined' as a value
+        if (value === 'undefined') {
+            return undefined;
+        }
+        const defaultValue = initialValue instanceof Function ? initialValue() : initialValue;
+        let parsed;
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch (err) {
+            console.error(`Error parsing JSON: ${err.message}`);
+            return defaultValue;
+        }
+        return parsed;
+    }, [options, initialValue]);
+    // Get from session storage then
+    // parse stored json or return initialValue
+    const readValue = useCallback(() => {
+        const initialValueToUse = initialValue instanceof Function ? initialValue() : initialValue;
+        // Prevent build error "window is undefined" but keep keep working
+        if (!isBrowser()) {
+            return initialValueToUse;
+        }
+        const raw = window.sessionStorage.getItem(key);
+        return raw ? deserializer(raw) : initialValueToUse;
+    }, [initialValue, key, deserializer]);
+    const [storedValue, setStoredValue] = useState(() => {
+        if (initializeWithValue) {
+            return readValue();
+        }
+        return initialValue instanceof Function ? initialValue() : initialValue;
+    });
+    // Return a wrapped version of useState's setter function that ...
+    // ... persists the new value to sessionStorage.
+    const setValue = useEventCallback((value) => {
+        // Prevent build error "window is undefined" but keeps working
+        if (!isBrowser()) {
+            console.warn(`Tried setting sessionStorage key “${key}” even though environment is not a client`);
+        }
+        try {
+            // Allow value to be a function so we have the same API as useState
+            const newValue = value instanceof Function ? value(readValue()) : value;
+            // Save to session storage
+            window.sessionStorage.setItem(key, serializer(newValue));
+            // Save state
+            setStoredValue(newValue);
+            // We dispatch a custom event so every similar useSessionStorage hook is notified
+            window.dispatchEvent(new StorageEvent('session-storage', { key }));
+        }
+        catch (error) {
+            console.warn(`Error setting sessionStorage key “${key}”:`, error);
+        }
+    });
+    useEffect(() => {
+        setStoredValue(readValue());
+    }, [key]);
+    const handleStorageChange = useCallback((event) => {
+        if (event.key && event.key !== key) {
+            return;
+        }
+        setStoredValue(readValue());
+    }, [key, readValue]);
+    // this only works for other documents, not the current one
+    useEventListener('storage', handleStorageChange);
+    // this is a custom event, triggered in writeValueToSessionStorage
+    // See: useSessionStorage()
+    useEventListener('session-storage', handleStorageChange);
+    return [storedValue, setValue];
+}

package/dist/hooks/useTheme.d.ts

@@ -0,0 +1,19 @@
+type Theme = 'dark' | 'light';
+type UpdateTheme = (theme: Theme) => void;
+/** @private */
+declare const DEFAULT_THEME: Theme;
+/** @private */
+declare const THEME_ATTRIBUTE = "data-mode";
+/** @private */
+declare const THEME_KEY = "theme";
+/** @private */
+declare const SYS_DARK_MEDIA_QUERY = "(prefers-color-scheme: dark)";
+/**
+ * Returns the current theme and a function to update the current theme
+ *
+ * The reason the implementation of this hook is rather convoluted is for
+ * cases where the theme is updated outside this hook
+ */
+declare function useTheme(): readonly [Theme, UpdateTheme];
+export { DEFAULT_THEME, SYS_DARK_MEDIA_QUERY, THEME_ATTRIBUTE, THEME_KEY, type Theme, useTheme };
+//# sourceMappingURL=useTheme.d.ts.map

package/dist/hooks/useTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../src/hooks/useTheme.ts"],"names":[],"mappings":"AAIA,KAAK,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;AAE9B,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAE1C,eAAe;AACf,QAAA,MAAM,aAAa,EAAE,KAAe,CAAC;AAErC,eAAe;AACf,QAAA,MAAM,eAAe,cAAc,CAAC;AAEpC,eAAe;AACf,QAAA,MAAM,SAAS,UAAU,CAAC;AAE1B,eAAe;AACf,QAAA,MAAM,oBAAoB,iCAAiC,CAAC;AAE5D;;;;;GAKG;AACH,iBAAS,QAAQ,IAAI,SAAS,CAAC,KAAK,EAAE,WAAW,CAAC,CA8CjD;AAED,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,eAAe,EAAE,SAAS,EAAE,KAAK,KAAK,EAAE,QAAQ,EAAE,CAAC"}

package/dist/hooks/useTheme.js

@@ -0,0 +1,60 @@
+import { useCallback, useEffect, useState } from 'react';
+import { isBrowser } from '../utils.js';
+/** @private */
+const DEFAULT_THEME = 'light';
+/** @private */
+const THEME_ATTRIBUTE = 'data-mode';
+/** @private */
+const THEME_KEY = 'theme';
+/** @private */
+const SYS_DARK_MEDIA_QUERY = '(prefers-color-scheme: dark)';
+/**
+ * Returns the current theme and a function to update the current theme
+ *
+ * The reason the implementation of this hook is rather convoluted is for
+ * cases where the theme is updated outside this hook
+ */
+function useTheme() {
+    // Initial theme value is based on the value saved in local storage or the system theme
+    const [theme, setTheme] = useState(() => {
+        if (!isBrowser()) {
+            return DEFAULT_THEME;
+        }
+        const savedTheme = window.localStorage.getItem(THEME_KEY);
+        let initialTheme;
+        if (savedTheme === 'dark' || savedTheme === 'light') {
+            initialTheme = savedTheme;
+        }
+        else {
+            initialTheme = window.matchMedia(SYS_DARK_MEDIA_QUERY).matches ? 'dark' : 'light';
+        }
+        document.documentElement.setAttribute(THEME_ATTRIBUTE, initialTheme);
+        return initialTheme;
+    });
+    useEffect(() => {
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.attributeName === THEME_ATTRIBUTE) {
+                    const updatedTheme = mutation.target.getAttribute(THEME_ATTRIBUTE);
+                    if (updatedTheme === 'light' || updatedTheme === 'dark') {
+                        window.localStorage.setItem(THEME_KEY, updatedTheme);
+                        setTheme(updatedTheme);
+                    }
+                    else {
+                        console.error(`Unexpected value for 'data-mode' attribute: ${updatedTheme}`);
+                    }
+                }
+            });
+        });
+        observer.observe(document.documentElement, {
+            attributes: true
+        });
+        return () => observer.disconnect();
+    }, []);
+    // When the user wants to change the theme
+    const updateTheme = useCallback((theme) => {
+        document.documentElement.setAttribute(THEME_ATTRIBUTE, theme);
+    }, [document.documentElement]);
+    return [theme, updateTheme];
+}
+export { DEFAULT_THEME, SYS_DARK_MEDIA_QUERY, THEME_ATTRIBUTE, THEME_KEY, useTheme };

package/dist/hooks/useWindowSize.d.ts

@@ -0,0 +1,6 @@
+export type WindowSize = {
+    height: number;
+    width: number;
+};
+export declare function useWindowSize(): WindowSize;
+//# sourceMappingURL=useWindowSize.d.ts.map

package/dist/hooks/useWindowSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWindowSize.d.ts","sourceRoot":"","sources":["../../src/hooks/useWindowSize.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAgB,aAAa,IAAI,UAAU,CAqB1C"}

package/dist/hooks/useWindowSize.js

@@ -0,0 +1,21 @@
+import { useState } from 'react';
+import { useEventListener } from './useEventListener.js';
+import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect.js';
+export function useWindowSize() {
+    const [windowSize, setWindowSize] = useState({
+        height: 0,
+        width: 0
+    });
+    const handleSize = () => {
+        setWindowSize({
+            height: window.innerHeight,
+            width: window.innerWidth
+        });
+    };
+    useEventListener('resize', handleSize);
+    // Set size at the first client-side load
+    useIsomorphicLayoutEffect(() => {
+        handleSize();
+    }, []);
+    return windowSize;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,13 @@
+export * from './hooks/useDownload.js';
+export * from './hooks/useEventCallback.js';
+export * from './hooks/useEventListener.js';
+export * from './hooks/useInterval.js';
+export * from './hooks/useIsomorphicLayoutEffect.js';
+export * from './hooks/useLegacyStepper.js';
+export * from './hooks/useMediaQuery.js';
+export * from './hooks/useNotificationsStore.js';
+export * from './hooks/useOnClickOutside.js';
+export * from './hooks/useSessionStorage.js';
+export * from './hooks/useTheme.js';
+export * from './hooks/useWindowSize.js';
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC"}

package/dist/hooks.js

@@ -0,0 +1,12 @@
+export * from './hooks/useDownload.js';
+export * from './hooks/useEventCallback.js';
+export * from './hooks/useEventListener.js';
+export * from './hooks/useInterval.js';
+export * from './hooks/useIsomorphicLayoutEffect.js';
+export * from './hooks/useLegacyStepper.js';
+export * from './hooks/useMediaQuery.js';
+export * from './hooks/useNotificationsStore.js';
+export * from './hooks/useOnClickOutside.js';
+export * from './hooks/useSessionStorage.js';
+export * from './hooks/useTheme.js';
+export * from './hooks/useWindowSize.js';

package/dist/i18n.d.ts

@@ -1,33 +1,32 @@
-import { i18n as i18n$1 } from 'i18next';
-import { EmptyObject, ValueOf } from 'type-fest';
-
-declare const supportedLngs: readonly ["en", "fr"];
-type Language = (typeof supportedLngs)[number];
-type TranslationsDef = {
+import { type i18n as I18n } from 'i18next';
+import type { EmptyObject, ValueOf } from 'type-fest';
+export declare const supportedLngs: readonly ["en", "fr"];
+export type Language = (typeof supportedLngs)[number];
+export type TranslationsDef = {
     [key: string]: {
         [key: string]: unknown;
     };
 };
-type TranslatedResource<T = EmptyObject> = {
+export type TranslatedResource<T = EmptyObject> = {
     [K in keyof T]: T[K] extends {
         [key: string]: unknown;
     } ? T[K] extends {
         [K in Language]: unknown;
     } ? ValueOf<T[K]> : TranslatedResource<T[K]> : T[K];
 };
-declare function transformTranslations<T extends {
+export declare function transformTranslations<T extends {
     [key: string]: any;
 }>(translations: T, locale: string): {
     [key: string]: unknown;
 };
-declare function createResourcesForLanguage<T extends TranslationsDef>(translations: T, locale: Language): { [P in keyof T]: {
+export declare function createResourcesForLanguage<T extends TranslationsDef>(translations: T, locale: Language): { [P in keyof T]: {
     [key: string]: unknown;
 }; };
-declare function createResources<T extends TranslationsDef>(translations: T): {
+export declare function createResources<T extends TranslationsDef>(translations: T): {
     en: TranslatedResource<T>;
     fr: TranslatedResource<T>;
 };
-declare const resources: {
+export declare const resources: {
     en: TranslatedResource<{
         libui: {
             days: {
@@ -341,8 +340,8 @@ declare const resources: {
         };
     }>;
 };
-declare const i18n: i18n$1 & {
+declare const i18n: I18n & {
     addPreInitTranslations<T extends TranslationsDef>(translations: T): void;
 };
-
-export { type Language, type TranslatedResource, type TranslationsDef, createResources, createResourcesForLanguage, i18n, resources, supportedLngs, transformTranslations };
+export { i18n };
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,IAAI,IAAI,EAAkB,MAAM,SAAS,CAAC;AAI5D,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAItD,eAAO,MAAM,aAAa,uBAAwB,CAAC;AAEnD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;CAAE,CAAC;AAE5E,MAAM,MAAM,kBAAkB,CAAC,CAAC,GAAG,WAAW,IAAI;KAC/C,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GACnD,CAAC,CAAC,CAAC,CAAC,SAAS;SAAG,CAAC,IAAI,QAAQ,GAAG,OAAO;KAAE,GACvC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACb,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC1B,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM;;EActG;AAED,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,eAAe,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ;;KAEtG;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,eAAe,EAAE,YAAY,EAAE,CAAC;;;EAKzE;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA6B,CAAC;AAEpD,QAAA,MAAM,IAAI;oEAUwD,CAAC,GAAG,IAAI;CACzE,CAAC;AAcF,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/i18n.js

@@ -1,219 +1,54 @@
-// src/i18n.ts
-import { isPlainObject } from "@douglasneuroinformatics/libjs";
-import { createInstance } from "i18next";
-import LanguageDetector from "i18next-browser-languagedetector";
-import { mapValues } from "lodash-es";
-import { initReactI18next } from "react-i18next";
-
-// src/translations/libui.json
-var libui_default = {
-  days: {
-    friday: {
-      en: "Friday",
-      fr: "Vendredi"
-    },
-    monday: {
-      en: "Monday",
-      fr: "Lundi"
-    },
-    saturday: {
-      en: "Saturday",
-      fr: "Samedi"
-    },
-    sunday: {
-      en: "Sunday",
-      fr: "Dimanche"
-    },
-    thursday: {
-      en: "Thursday",
-      fr: "Jeudi"
-    },
-    tuesday: {
-      en: "Tuesday",
-      fr: "Mardi"
-    },
-    wednesday: {
-      en: "Wednesday",
-      fr: "Mercredi"
-    }
-  },
-  form: {
-    append: {
-      en: "Append",
-      fr: "Ajouter"
-    },
-    radioLabels: {
-      false: {
-        en: "False",
-        fr: "Faux"
-      },
-      true: {
-        en: "True",
-        fr: "Vrai"
-      }
-    },
-    remove: {
-      en: "Remove",
-      fr: "Supprimer"
-    },
-    required: {
-      en: "This field is required",
-      fr: "Ce champ est obligatoire"
-    },
-    reset: {
-      en: "Reset",
-      fr: "R\xE9initialiser"
-    },
-    submit: {
-      en: "Submit",
-      fr: "Soumettre"
-    }
-  },
-  months: {
-    april: {
-      en: "April",
-      fr: "Avril"
-    },
-    august: {
-      en: "August",
-      fr: "Ao\xFBt"
-    },
-    december: {
-      en: "December",
-      fr: "D\xE9cembre"
-    },
-    february: {
-      en: "February",
-      fr: "F\xE9vrier"
-    },
-    january: {
-      en: "January",
-      fr: "Janvier"
-    },
-    july: {
-      en: "July",
-      fr: "Juillet"
-    },
-    june: {
-      en: "June",
-      fr: "Juin"
-    },
-    march: {
-      en: "March",
-      fr: "Mars"
-    },
-    may: {
-      en: "May",
-      fr: "Mai"
-    },
-    november: {
-      en: "November",
-      fr: "Novembre"
-    },
-    october: {
-      en: "October",
-      fr: "Octobre"
-    },
-    september: {
-      en: "September",
-      fr: "Septembre"
+import { isPlainObject } from '@douglasneuroinformatics/libjs';
+import { createInstance } from 'i18next';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import { mapValues } from 'lodash-es';
+import { initReactI18next } from 'react-i18next';
+import libui from './translations/libui.json';
+export const supportedLngs = ['en', 'fr'];
+export function transformTranslations(translations, locale) {
+    if (!isPlainObject) {
+        throw new Error('Invalid format of translations: must be plain object');
     }
-  },
-  notifications: {
-    types: {
-      error: {
-        en: "Error",
-        fr: "Erreur"
-      },
-      info: {
-        en: "Info",
-        fr: "Attention"
-      },
-      success: {
-        en: "Success",
-        fr: "Succ\xE8s"
-      },
-      warning: {
-        en: "Warning",
-        fr: "Avertissement"
-      }
+    const result = {};
+    for (const key in translations) {
+        const value = translations[key];
+        if (Object.hasOwn(value, locale)) {
+            result[key] = value[locale];
+        }
+        else {
+            result[key] = transformTranslations(value, locale);
+        }
     }
-  },
-  pagination: {
-    info: {
-      en: "Showing {{first}} to {{last}} of {{total}} results",
-      fr: "Affichage de {{first}} \xE0 {{last}} sur {{total}} r\xE9sultats"
-    },
-    next: {
-      en: "Next",
-      fr: "Suivant"
-    },
-    previous: {
-      en: "Previous",
-      fr: "Pr\xE9c\xE9dent"
-    }
-  },
-  searchBar: {
-    placeholder: {
-      en: "Search...",
-      fr: "Rechercher..."
-    }
-  }
-};
-
-// src/i18n.ts
-var supportedLngs = ["en", "fr"];
-function transformTranslations(translations, locale) {
-  if (!isPlainObject) {
-    throw new Error("Invalid format of translations: must be plain object");
-  }
-  const result = {};
-  for (const key in translations) {
-    const value = translations[key];
-    if (Object.hasOwn(value, locale)) {
-      result[key] = value[locale];
-    } else {
-      result[key] = transformTranslations(value, locale);
-    }
-  }
-  return result;
+    return result;
 }
-function createResourcesForLanguage(translations, locale) {
-  return mapValues(translations, (value) => transformTranslations(value, locale));
+export function createResourcesForLanguage(translations, locale) {
+    return mapValues(translations, (value) => transformTranslations(value, locale));
 }
-function createResources(translations) {
-  return {
-    en: createResourcesForLanguage(translations, "en"),
-    fr: createResourcesForLanguage(translations, "fr")
-  };
+export function createResources(translations) {
+    return {
+        en: createResourcesForLanguage(translations, 'en'),
+        fr: createResourcesForLanguage(translations, 'fr')
+    };
 }
-var resources = createResources({ libui: libui_default });
-var i18n = createInstance({
-  fallbackLng: "en",
-  interpolation: {
-    escapeValue: false
-  },
-  lng: "en",
-  resources,
-  returnObjects: true,
-  supportedLngs
+export const resources = createResources({ libui });
+const i18n = createInstance({
+    fallbackLng: 'en',
+    interpolation: {
+        escapeValue: false
+    },
+    lng: 'en',
+    resources,
+    returnObjects: true,
+    supportedLngs
 });
-i18n.addPreInitTranslations = function(translations) {
-  if (!this.options.resources) {
-    console.error("Cannot add additional translations to i18next instance: 'this.options.resources' is undefined");
-    return;
-  }
-  const resources2 = createResources(translations);
-  Object.assign(this.options.resources.en, resources2.en);
-  Object.assign(this.options.resources.fr, resources2.fr);
+i18n.addPreInitTranslations = function (translations) {
+    if (!this.options.resources) {
+        console.error("Cannot add additional translations to i18next instance: 'this.options.resources' is undefined");
+        return;
+    }
+    const resources = createResources(translations);
+    Object.assign(this.options.resources.en, resources.en);
+    Object.assign(this.options.resources.fr, resources.fr);
 };
 i18n.use(initReactI18next).use(LanguageDetector);
-export {
-  createResources,
-  createResourcesForLanguage,
-  i18n,
-  resources,
-  supportedLngs,
-  transformTranslations
-};
-//# sourceMappingURL=i18n.js.map
+export { i18n };

package/dist/testing/mocks.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mocks the matchMedia API
+ * @param {boolean} matches - whether the media query matches
+ * @example
+ * mockMatchMedia(false)
+ */
+export declare const mockMatchMedia: (matches: boolean | ((query: string) => boolean)) => void;
+/**
+ * Mocks the Storage API
+ * @param {'localStorage' | 'sessionStorage'} name - The name of the storage to mock
+ * @example
+ * mockStorage('localStorage')
+ * // Then use window.localStorage as usual (it will be mocked)
+ */
+export declare const mockStorage: (name: 'localStorage' | 'sessionStorage') => void;
+//# sourceMappingURL=mocks.d.ts.map

package/dist/testing/mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/testing/mocks.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,+BAAsB,MAAM,KAAK,OAAO,MAAc,IAWhF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,SAAU,cAAc,GAAG,gBAAgB,KAAG,IAwBrE,CAAC"}

package/dist/testing/mocks.js

@@ -0,0 +1,46 @@
+import { vi } from 'vitest';
+/**
+ * Mocks the matchMedia API
+ * @param {boolean} matches - whether the media query matches
+ * @example
+ * mockMatchMedia(false)
+ */
+export const mockMatchMedia = (matches) => {
+    vi.spyOn(window, 'matchMedia').mockImplementation((query) => ({
+        addEventListener: vi.fn(),
+        addListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+        matches: typeof matches === 'boolean' ? matches : matches(query),
+        media: query,
+        onchange: null,
+        removeEventListener: vi.fn(),
+        removeListener: vi.fn()
+    }));
+};
+/**
+ * Mocks the Storage API
+ * @param {'localStorage' | 'sessionStorage'} name - The name of the storage to mock
+ * @example
+ * mockStorage('localStorage')
+ * // Then use window.localStorage as usual (it will be mocked)
+ */
+export const mockStorage = (name) => {
+    class StorageMock {
+        store = {};
+        clear() {
+            this.store = {};
+        }
+        getItem(key) {
+            return this.store[key] || null;
+        }
+        removeItem(key) {
+            delete this.store[key];
+        }
+        setItem(key, value) {
+            this.store[key] = String(value) + '';
+        }
+    }
+    Object.defineProperty(window, name, {
+        value: new StorageMock()
+    });
+};

package/dist/testing/setup-tests.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom/vitest';
+//# sourceMappingURL=setup-tests.d.ts.map

package/dist/testing/setup-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-tests.d.ts","sourceRoot":"","sources":["../../src/testing/setup-tests.ts"],"names":[],"mappings":"AAGA,OAAO,kCAAkC,CAAC"}

package/dist/testing/setup-tests.js

@@ -0,0 +1,8 @@
+import { cleanup } from '@testing-library/react';
+import { afterEach, vi } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+vi.mock('zustand');
+// Since we're not using vitest globals, we need to explicitly call cleanup()
+// for testing-library. See:
+// https://testing-library.com/docs/react-testing-library/api/#cleanup
+afterEach(cleanup);