@react-md/core 1.0.0-next.11 → 1.0.0-next.13

package/dist/useLocalStorage.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useLocalStorage.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useSsr } from \"./SsrProvider.js\";\nimport type { UseStateInitializer, UseStateSetter } from \"./types.js\";\nimport { useIsomorphicLayoutEffect } from \"./useIsomorphicLayoutEffect.js\";\nimport { identity } from \"./utils/identity.js\";\n\n/** @remarks \\@since 6.0.0 */\nexport type LocalStorageSerializer<T> = (value: T) => string;\n/** @remarks \\@since 6.0.0 */\nexport type LocalStorageDeserializer<T> = (item: string) => T;\n\n/** @remarks \\@since 6.0.0 */\nexport interface LocalStorageHookOptions<T> {\n  /**\n   * The local storage key name to use.\n   *\n   * This can be set to an empty string for internal usage of conditionally\n   * saving items to local storage.\n   */\n  key: string;\n\n  /**\n   * The default value to use if an item does not exist in local storage.\n   */\n  defaultValue: UseStateInitializer<T>;\n\n  /**\n   * Set this to `true` if the `value` should not persist to local storage\n   * immediately whenever it changes. You will manually need to call\n   * {@link LocalStorageHookReturnValue.persist} instead.\n   *\n   * @see {@link LocalStorageHookReturnValue.persist} for an example.\n   * @defaultValue `false`\n   */\n  manual?: boolean;\n\n  /**\n   * Set this to `true` to update:\n   *\n   * - the default {@link serializer} to be:\n   * ```\n   * typeof value === \"string\" ? value : `${value}`\n   * ```\n   * - the default {@link deserializer} to not call `JSON.parse` if the\n   *   {@link defaultValue} is a string.\n   *\n   * @defaultValue `typeof defaultValue === 'string'`\n   */\n  raw?: boolean;\n\n  /**\n   * An optional function to serialize the `value` before storing it in local\n   * storage.\n   *\n   * @defaultValue `JSON.stringify`\n   */\n  serializer?: LocalStorageSerializer<T>;\n\n  /**\n   * An optional function to deserialize the `value` if the item existed in\n   * local storage.\n   *\n   * @defaultValue `JSON.parse`\n   */\n  deserializer?: LocalStorageDeserializer<T>;\n}\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport const defaultLocalStorageSerializer = <T>(value: T): string =>\n  typeof value === \"string\" ? value : `${value}`;\n\n/** @remarks \\@since 6.0.0 */\nexport interface GetItemFromStorageOptions<T> {\n  /**\n   * The storage key to use\n   */\n  key: string;\n\n  /**\n   * A value to use when the {@link key} does not exist in storage or there is\n   * an error deserializing the value.\n   */\n  fallback: T;\n\n  /** @see {@link LocalStorageHookOptions.deserializer} */\n  deserializer?: LocalStorageDeserializer<T>;\n\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n}\n\n/**\n * You'll most likely want to use {@link useLocalStorage} instead, but this is a\n * low-level util to \"safely\" get an item from local storage.\n *\n * @example\n * ```ts\n * import { getItemFromStorage } from \"@react-md/core\";\n *\n * const values = [\"a\", \"b\", \"c\", \"d\"] as const;\n *\n * const item1 = getItemFromStorage({\n *   key: \"testKey\",\n *   fallback: values[0],\n *   deserializer(item) {\n *     if (!values.includes(item)) {\n *       return values[0]\n *     }\n *\n *     return item;\n *   },\n * });\n *\n * const item2 = getItemFromStorage({\n *   key: \"anotherKey\",\n *   fallback: -1,\n * });\n *\n * const item3 = getItemFromStorage({\n *   key: \"anotherKey\",\n *   fallback: -1,\n *   storage: sessionStorage,\n * });\n * ```\n *\n * @remarks \\@since 6.0.0\n */\nexport const getItemFromStorage = <T>(\n  options: GetItemFromStorageOptions<T>\n): T => {\n  const {\n    key,\n    fallback,\n    storage = localStorage,\n    deserializer = JSON.parse,\n  } = options;\n  if (!key) {\n    return fallback;\n  }\n\n  try {\n    const value = storage.getItem(key);\n    return !value ? fallback : deserializer(value);\n  } catch (e) {\n    return fallback;\n  }\n};\n\n/** @remarks \\@since 6.0.0 */\nexport interface SetItemInStorageOptions<T> {\n  key: string;\n  value: T;\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n\n  /** @see {@link LocalStorageHookOptions.serializer} */\n  serializer?: LocalStorageSerializer<T>;\n}\n\n/**\n * You'll most likely want to use {@link useLocalStorage} instead, but this is a\n * low-level util to \"safely\" get an item from local storage.\n *\n * @example\n * ```ts\n * import { identity, getItemFromStorage } from \"@react-md/core\";\n *\n * const values = [\"a\", \"b\", \"c\", \"d\"] as const;\n *\n * setItemInStorage({\n *   key: \"testKey\",\n *   value: values[0],\n *   // store string value as-is\n *   serializer: identity,\n * });\n *\n * setItemInStorage({\n *   key: \"anotherKey\",\n *   value: 100,\n * });\n *\n * setItemInStorage({\n *   key: \"anotherKey\",\n *   value: 100,\n *   storage: sessionStorage,\n * });\n * ```\n *\n * @remarks \\@since 6.0.0\n */\nexport const setItemInStorage = <T>(\n  options: SetItemInStorageOptions<T>\n): void => {\n  const {\n    key,\n    value,\n    storage = localStorage,\n    serializer = JSON.stringify,\n  } = options;\n  if (!key) {\n    return;\n  }\n\n  try {\n    storage.setItem(key, serializer(value));\n  } catch {\n    //\n  }\n};\n\n/**\n * @remarks \\@since 6.0.0\n * @internal\n */\ninterface RemoveItemFromStorageOptions {\n  key: string;\n\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n}\n\n/**\n * @remarks \\@since 6.0.0\n * @internal\n */\nexport const removeItemFromStorage = (\n  options: RemoveItemFromStorageOptions\n): void => {\n  const { key, storage = localStorage } = options;\n  if (!key) {\n    return;\n  }\n\n  try {\n    storage.removeItem(key);\n  } catch {\n    // do nothing\n  }\n};\n\n/** @remarks \\@since 6.0.0 */\nexport interface LocalStorageHookReturnValue<T> {\n  value: T;\n\n  /**\n   * Updates the {@link value} in state. When the\n   * {@link LocalStorageHookOptions.manual} option is `false`, the value will\n   * also be updated in local storage immediately.\n   */\n  setValue: UseStateSetter<T>;\n\n  /**\n   * Remove the item from local storage.\n   */\n  remove(): void;\n\n  /**\n   * Manually persist the current {@link value} into local storage. This is only\n   * useful if the {@link LocalStorageHookOptions.manual} option is `true`.\n   *\n   * @example\n   * Manual Persisting\n   * ```tsx\n   * import type { ReactElement } from \"react\";\n   *\n   * function Example(): ReactElement {\n   *   const { value, setValue, persist } = useLocalStorage({\n   *     key: \"someKey\",\n   *     manual: true,\n   *     defaultValue: \"\",\n   *   });\n   *\n   *   return (\n   *     <>\n   *       <Button onClick={closeDialog}>\n   *         Cancel\n   *       </Button>\n   *       <Button\n   *         onClick={async () => {\n   *           await saveToDatabase(value);\n   *           persist();\n   *           closeDialog();\n   *         }}\n   *       >\n   *         Confirm\n   *       </Button>\n   *     </>\n   *   );\n   * }\n   * ```\n   */\n  persist(): void;\n}\n\n/**\n * @example\n * Simple Example\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { TextField, useLocalStorage } from \"@react-md/core\";\n *\n * function Example(): ReactElement {\n *   const { value, setValue } = useLocalStorage({\n *     key: \"savedSearch\",\n *     defaultValue: \"\",\n *   });\n *\n *   return (\n *     <TextField\n *       label=\"Search\"\n *       placeholder=\"Search...\"\n *       type=\"search\"\n *       value={value}\n *       onChange={(event) => {\n *         setValue(event.currentTarget.value)\n *       }}\n *     />\n *   );\n * }\n * ```\n *\n * @example\n * Type-safe Objects\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { useLocalStorage } from \"@react-md/core\";\n *\n * interface ExpectedSchema {\n *   label: string;\n *   value: string;\n *   // others\n * }\n *\n * function Example(): ReactElement {\n *   const { value, setValue } = useLocalStorage<ExpectedSchema | null>({\n *     key: \"someKey\",\n *     defaultValue: null,\n *\n *     // this is optional: you can create a custom deserializer to validate\n *     // the stored value to prevent people manually updating local storage in\n *     // the dev tools\n *     deserializer(item) {\n *       const parsed = JSON.parse(item):\n *       const { label, value } = parsed;\n *       if (typeof label !== 'string' || typeof value !== 'string') {\n *         return null;\n *       }\n *\n *       return { label, value };\n *     }\n *   });\n *\n *   // do something\n *   // value will be `ExpectedSchema | null`\n * }\n * ```\n *\n * @example\n * Manual Persistence\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { Button, Checkbox, Form, useLocalStorage } from \"@react-md/core\";\n *\n * function Example(): ReactElement {\n *   const { value, setValue, remove, persist } = useLocalStorage({\n *     key: \"someKey\",\n *     manual: true,\n *     defaultValue: false,\n *   });\n *\n *   return (\n *     <Form\n *       onSubmit={() => {\n *         // current value will be saved into local storage\n *         persist();\n *       }}\n *       onReset={() => {\n *         // \"someKey\" will be removed from local storage\n *         remove();\n *       }}\n *     >\n *       <Checkbox\n *         label=\"Allow cookies\"\n *         checked={value}\n *         onChange={(event) =>\n *           setValue(event.currentTarget.checked);\n *         }\n *       />\n *       <Button type=\"reset\">Decline</Button>\n *       <Button type=\"submit\">Save</Button>\n *     </Form>\n *   );\n * }\n * ```\n *\n * Note: Using the same local storage key in multiple parts in your app will not\n * update all instances with that value. The value will only be updated if it\n * was updated in a separate tab with the `\"storage\"` event. You must setup your\n * own context to share values or another state manager solution.\n *\n * @example\n * Shared Value\n * ```tsx\n * const context = createContext(null);\n * const { Provider } = context;\n *\n * export function useSomeValue(): string {\n *   const value = useContext(context);\n *   if (!value) {\n *     throw new Error()\n *   }\n *\n *   return value;\n * }\n *\n * function Example({ children }: { children: ReactNode }) {\n *   const { value, setValue, remove, persist } = useLocalStorage({\n *     key: \"someKey\",\n *     defaultValue: \"\",\n *\n *     // optional\n *     manual: true,\n *   });\n *\n *   return (\n *     <Provider\n *       value={useMemo(() => ({\n *         value,\n *         setValue,\n *\n *         // remove and persist are optional\n *         remove,\n *         persist,\n *       }), [value, setValue, remove, persist])}\n *     >\n *       {children}\n *     </Provider>\n *   );\n * }\n *\n * function SomeChildComponent() {\n *   const { value, setValue } = useSomeValue();\n *   // do stuff\n * }\n * ```\n *\n * @remarks \\@since 6.0.0\n */\nexport function useLocalStorage<T>(\n  options: LocalStorageHookOptions<T>\n): LocalStorageHookReturnValue<T> {\n  const { key, defaultValue, manual = false } = options;\n\n  const [initialValue] = useState(defaultValue);\n  // this allows for strings to automatically be stored as-is instead of adding\n  // additional quotes around then with JSON.stringify\n  const raw = options.raw ?? typeof initialValue === \"string\";\n  const serializer =\n    options.serializer ??\n    (raw ? defaultLocalStorageSerializer : JSON.stringify);\n  const deserializer =\n    options.deserializer ??\n    (raw && typeof initialValue === \"string\" ? identity : JSON.parse);\n\n  const ssr = useSsr();\n  const [value, setStoredValue] = useState<T>(() => {\n    if (ssr) {\n      return initialValue;\n    }\n\n    const value = getItemFromStorage({\n      key,\n      fallback: initialValue,\n      deserializer,\n    });\n    if (!manual) {\n      setItemInStorage({\n        key,\n        value,\n        serializer,\n      });\n    }\n\n    return value;\n  });\n  const config = useRef({\n    key,\n    value,\n    manual,\n    serializer,\n    deserializer,\n    defaultValue: initialValue,\n  } as const);\n  useIsomorphicLayoutEffect(() => {\n    config.current = {\n      key,\n      value,\n      manual,\n      serializer,\n      deserializer,\n      defaultValue: initialValue,\n    };\n  });\n\n  const setValue = useCallback<UseStateSetter<T>>((valueOrDispatcher) => {\n    const { key, manual, serializer } = config.current;\n    setStoredValue((prevValue) => {\n      const nextValue =\n        valueOrDispatcher instanceof Function\n          ? valueOrDispatcher(prevValue)\n          : valueOrDispatcher;\n\n      if (!manual) {\n        setItemInStorage({\n          key,\n          value: nextValue,\n          serializer,\n        });\n      }\n\n      return nextValue;\n    });\n  }, []);\n\n  const remove = useCallback(() => {\n    removeItemFromStorage({\n      key: config.current.key,\n    });\n  }, []);\n\n  const persist = useCallback(() => {\n    const { key, value, serializer } = config.current;\n    setItemInStorage({\n      key,\n      value,\n      serializer,\n    });\n  }, []);\n\n  useEffect(() => {\n    const { defaultValue, deserializer, manual } = config.current;\n    if (manual || !ssr) {\n      return;\n    }\n\n    setValue(\n      getItemFromStorage({\n        key,\n        fallback: defaultValue,\n        deserializer,\n      })\n    );\n  }, [key, ssr, setValue]);\n\n  // update the value if another tab changed the local storage value\n  useEffect(() => {\n    if (!key) {\n      return;\n    }\n\n    const callback = (event: StorageEvent): void => {\n      const { defaultValue, deserializer } = config.current;\n      if (event.key === key) {\n        setStoredValue(\n          getItemFromStorage({\n            key,\n            fallback: defaultValue,\n            deserializer,\n          })\n        );\n      }\n    };\n\n    window.addEventListener(\"storage\", callback);\n    return () => {\n      window.removeEventListener(\"storage\", callback);\n    };\n  }, [key]);\n\n  return {\n    value,\n    setValue,\n    remove,\n    persist,\n  };\n}\n"],"names":["useCallback","useEffect","useRef","useState","useSsr","useIsomorphicLayoutEffect","identity","defaultLocalStorageSerializer","value","getItemFromStorage","options","key","fallback","storage","localStorage","deserializer","JSON","parse","getItem","e","setItemInStorage","serializer","stringify","setItem","removeItemFromStorage","removeItem","useLocalStorage","defaultValue","manual","initialValue","raw","ssr","setStoredValue","config","current","setValue","valueOrDispatcher","prevValue","nextValue","Function","remove","persist","callback","event","window","addEventListener","removeEventListener"],"mappings":"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"}
+{"version":3,"sources":["../src/useLocalStorage.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useSsr } from \"./SsrProvider.js\";\nimport type { UseStateInitializer, UseStateSetter } from \"./types.js\";\nimport { useIsomorphicLayoutEffect } from \"./useIsomorphicLayoutEffect.js\";\nimport { identity } from \"./utils/identity.js\";\n\n/** @since 6.0.0 */\nexport type LocalStorageSerializer<T> = (value: T) => string;\n/** @since 6.0.0 */\nexport type LocalStorageDeserializer<T> = (item: string) => T;\n\n/** @since 6.0.0 */\nexport interface LocalStorageHookOptions<T> {\n  /**\n   * The local storage key name to use.\n   *\n   * This can be set to an empty string for internal usage of conditionally\n   * saving items to local storage.\n   */\n  key: string;\n\n  /**\n   * The default value to use if an item does not exist in local storage.\n   */\n  defaultValue: UseStateInitializer<T>;\n\n  /**\n   * Set this to `true` if the `value` should not persist to local storage\n   * immediately whenever it changes. You will manually need to call\n   * {@link LocalStorageHookReturnValue.persist} instead.\n   *\n   * @see {@link LocalStorageHookReturnValue.persist} for an example.\n   * @defaultValue `false`\n   */\n  manual?: boolean;\n\n  /**\n   * Set this to `true` to update:\n   *\n   * - the default {@link serializer} to be:\n   * ```\n   * typeof value === \"string\" ? value : `${value}`\n   * ```\n   * - the default {@link deserializer} to not call `JSON.parse` if the\n   *   {@link defaultValue} is a string.\n   *\n   * @defaultValue `typeof defaultValue === 'string'`\n   */\n  raw?: boolean;\n\n  /**\n   * An optional function to serialize the `value` before storing it in local\n   * storage.\n   *\n   * @defaultValue `JSON.stringify`\n   */\n  serializer?: LocalStorageSerializer<T>;\n\n  /**\n   * An optional function to deserialize the `value` if the item existed in\n   * local storage.\n   *\n   * @defaultValue `JSON.parse`\n   */\n  deserializer?: LocalStorageDeserializer<T>;\n}\n\n/**\n * @since 6.0.0\n */\nexport const defaultLocalStorageSerializer = <T>(value: T): string =>\n  typeof value === \"string\" ? value : `${value}`;\n\n/** @since 6.0.0 */\nexport interface GetItemFromStorageOptions<T> {\n  /**\n   * The storage key to use\n   */\n  key: string;\n\n  /**\n   * A value to use when the {@link key} does not exist in storage or there is\n   * an error deserializing the value.\n   */\n  fallback: T;\n\n  /** @see {@link LocalStorageHookOptions.deserializer} */\n  deserializer?: LocalStorageDeserializer<T>;\n\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n}\n\n/**\n * You'll most likely want to use {@link useLocalStorage} instead, but this is a\n * low-level util to \"safely\" get an item from local storage.\n *\n * @example\n * ```ts\n * import { getItemFromStorage } from \"@react-md/core\";\n *\n * const values = [\"a\", \"b\", \"c\", \"d\"] as const;\n *\n * const item1 = getItemFromStorage({\n *   key: \"testKey\",\n *   fallback: values[0],\n *   deserializer(item) {\n *     if (!values.includes(item)) {\n *       return values[0]\n *     }\n *\n *     return item;\n *   },\n * });\n *\n * const item2 = getItemFromStorage({\n *   key: \"anotherKey\",\n *   fallback: -1,\n * });\n *\n * const item3 = getItemFromStorage({\n *   key: \"anotherKey\",\n *   fallback: -1,\n *   storage: sessionStorage,\n * });\n * ```\n *\n * @since 6.0.0\n */\nexport const getItemFromStorage = <T>(\n  options: GetItemFromStorageOptions<T>\n): T => {\n  const {\n    key,\n    fallback,\n    storage = localStorage,\n    deserializer = JSON.parse,\n  } = options;\n  if (!key) {\n    return fallback;\n  }\n\n  try {\n    const value = storage.getItem(key);\n    return !value ? fallback : deserializer(value);\n  } catch (e) {\n    return fallback;\n  }\n};\n\n/** @since 6.0.0 */\nexport interface SetItemInStorageOptions<T> {\n  key: string;\n  value: T;\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n\n  /** @see {@link LocalStorageHookOptions.serializer} */\n  serializer?: LocalStorageSerializer<T>;\n}\n\n/**\n * You'll most likely want to use {@link useLocalStorage} instead, but this is a\n * low-level util to \"safely\" get an item from local storage.\n *\n * @example\n * ```ts\n * import { identity, getItemFromStorage } from \"@react-md/core\";\n *\n * const values = [\"a\", \"b\", \"c\", \"d\"] as const;\n *\n * setItemInStorage({\n *   key: \"testKey\",\n *   value: values[0],\n *   // store string value as-is\n *   serializer: identity,\n * });\n *\n * setItemInStorage({\n *   key: \"anotherKey\",\n *   value: 100,\n * });\n *\n * setItemInStorage({\n *   key: \"anotherKey\",\n *   value: 100,\n *   storage: sessionStorage,\n * });\n * ```\n *\n * @since 6.0.0\n */\nexport const setItemInStorage = <T>(\n  options: SetItemInStorageOptions<T>\n): void => {\n  const {\n    key,\n    value,\n    storage = localStorage,\n    serializer = JSON.stringify,\n  } = options;\n  if (!key) {\n    return;\n  }\n\n  try {\n    storage.setItem(key, serializer(value));\n  } catch {\n    //\n  }\n};\n\n/**\n * @since 6.0.0\n * @internal\n */\ninterface RemoveItemFromStorageOptions {\n  key: string;\n\n  /** @defaultValue `localStorage` */\n  storage?: Storage;\n}\n\n/**\n * @since 6.0.0\n * @internal\n */\nexport const removeItemFromStorage = (\n  options: RemoveItemFromStorageOptions\n): void => {\n  const { key, storage = localStorage } = options;\n  if (!key) {\n    return;\n  }\n\n  try {\n    storage.removeItem(key);\n  } catch {\n    // do nothing\n  }\n};\n\n/** @since 6.0.0 */\nexport interface LocalStorageHookReturnValue<T> {\n  value: T;\n\n  /**\n   * Updates the {@link value} in state. When the\n   * {@link LocalStorageHookOptions.manual} option is `false`, the value will\n   * also be updated in local storage immediately.\n   */\n  setValue: UseStateSetter<T>;\n\n  /**\n   * Remove the item from local storage.\n   */\n  remove(): void;\n\n  /**\n   * Manually persist the current {@link value} into local storage. This is only\n   * useful if the {@link LocalStorageHookOptions.manual} option is `true`.\n   *\n   * @example Manual Persisting\n   * ```tsx\n   * import type { ReactElement } from \"react\";\n   *\n   * function Example(): ReactElement {\n   *   const { value, setValue, persist } = useLocalStorage({\n   *     key: \"someKey\",\n   *     manual: true,\n   *     defaultValue: \"\",\n   *   });\n   *\n   *   return (\n   *     <>\n   *       <Button onClick={closeDialog}>\n   *         Cancel\n   *       </Button>\n   *       <Button\n   *         onClick={async () => {\n   *           await saveToDatabase(value);\n   *           persist();\n   *           closeDialog();\n   *         }}\n   *       >\n   *         Confirm\n   *       </Button>\n   *     </>\n   *   );\n   * }\n   * ```\n   */\n  persist(): void;\n}\n\n/**\n * @example Simple Example\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { TextField, useLocalStorage } from \"@react-md/core\";\n *\n * function Example(): ReactElement {\n *   const { value, setValue } = useLocalStorage({\n *     key: \"savedSearch\",\n *     defaultValue: \"\",\n *   });\n *\n *   return (\n *     <TextField\n *       label=\"Search\"\n *       placeholder=\"Search...\"\n *       type=\"search\"\n *       value={value}\n *       onChange={(event) => {\n *         setValue(event.currentTarget.value)\n *       }}\n *     />\n *   );\n * }\n * ```\n *\n * @example Type-safe Objects\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { useLocalStorage } from \"@react-md/core\";\n *\n * interface ExpectedSchema {\n *   label: string;\n *   value: string;\n *   // others\n * }\n *\n * function Example(): ReactElement {\n *   const { value, setValue } = useLocalStorage<ExpectedSchema | null>({\n *     key: \"someKey\",\n *     defaultValue: null,\n *\n *     // this is optional: you can create a custom deserializer to validate\n *     // the stored value to prevent people manually updating local storage in\n *     // the dev tools\n *     deserializer(item) {\n *       const parsed = JSON.parse(item):\n *       const { label, value } = parsed;\n *       if (typeof label !== 'string' || typeof value !== 'string') {\n *         return null;\n *       }\n *\n *       return { label, value };\n *     }\n *   });\n *\n *   // do something\n *   // value will be `ExpectedSchema | null`\n * }\n * ```\n *\n * @example Manual Persistence\n * ```tsx\n * import type { ReactElement } from \"react\";\n * import { Button, Checkbox, Form, useLocalStorage } from \"@react-md/core\";\n *\n * function Example(): ReactElement {\n *   const { value, setValue, remove, persist } = useLocalStorage({\n *     key: \"someKey\",\n *     manual: true,\n *     defaultValue: false,\n *   });\n *\n *   return (\n *     <Form\n *       onSubmit={() => {\n *         // current value will be saved into local storage\n *         persist();\n *       }}\n *       onReset={() => {\n *         // \"someKey\" will be removed from local storage\n *         remove();\n *       }}\n *     >\n *       <Checkbox\n *         label=\"Allow cookies\"\n *         checked={value}\n *         onChange={(event) =>\n *           setValue(event.currentTarget.checked);\n *         }\n *       />\n *       <Button type=\"reset\">Decline</Button>\n *       <Button type=\"submit\">Save</Button>\n *     </Form>\n *   );\n * }\n * ```\n *\n * Note: Using the same local storage key in multiple parts in your app will not\n * update all instances with that value. The value will only be updated if it\n * was updated in a separate tab with the `\"storage\"` event. You must setup your\n * own context to share values or another state manager solution.\n *\n * @example Shared Value\n * ```tsx\n * const context = createContext(null);\n * const { Provider } = context;\n *\n * export function useSomeValue(): string {\n *   const value = useContext(context);\n *   if (!value) {\n *     throw new Error()\n *   }\n *\n *   return value;\n * }\n *\n * function Example({ children }: { children: ReactNode }) {\n *   const { value, setValue, remove, persist } = useLocalStorage({\n *     key: \"someKey\",\n *     defaultValue: \"\",\n *\n *     // optional\n *     manual: true,\n *   });\n *\n *   return (\n *     <Provider\n *       value={useMemo(() => ({\n *         value,\n *         setValue,\n *\n *         // remove and persist are optional\n *         remove,\n *         persist,\n *       }), [value, setValue, remove, persist])}\n *     >\n *       {children}\n *     </Provider>\n *   );\n * }\n *\n * function SomeChildComponent() {\n *   const { value, setValue } = useSomeValue();\n *   // do stuff\n * }\n * ```\n *\n * @since 6.0.0\n */\nexport function useLocalStorage<T>(\n  options: LocalStorageHookOptions<T>\n): LocalStorageHookReturnValue<T> {\n  const { key, defaultValue, manual = false } = options;\n\n  const [initialValue] = useState(defaultValue);\n  // this allows for strings to automatically be stored as-is instead of adding\n  // additional quotes around then with JSON.stringify\n  const raw = options.raw ?? typeof initialValue === \"string\";\n  const serializer =\n    options.serializer ??\n    (raw ? defaultLocalStorageSerializer : JSON.stringify);\n  const deserializer =\n    options.deserializer ??\n    (raw && typeof initialValue === \"string\" ? identity : JSON.parse);\n\n  const ssr = useSsr();\n  const [value, setStoredValue] = useState<T>(() => {\n    if (ssr) {\n      return initialValue;\n    }\n\n    const value = getItemFromStorage({\n      key,\n      fallback: initialValue,\n      deserializer,\n    });\n    if (!manual) {\n      setItemInStorage({\n        key,\n        value,\n        serializer,\n      });\n    }\n\n    return value;\n  });\n  const config = useRef({\n    key,\n    value,\n    manual,\n    serializer,\n    deserializer,\n    defaultValue: initialValue,\n  } as const);\n  useIsomorphicLayoutEffect(() => {\n    config.current = {\n      key,\n      value,\n      manual,\n      serializer,\n      deserializer,\n      defaultValue: initialValue,\n    };\n  });\n\n  const setValue = useCallback<UseStateSetter<T>>((valueOrDispatcher) => {\n    const { key, manual, serializer } = config.current;\n    setStoredValue((prevValue) => {\n      const nextValue =\n        valueOrDispatcher instanceof Function\n          ? valueOrDispatcher(prevValue)\n          : valueOrDispatcher;\n\n      if (!manual) {\n        setItemInStorage({\n          key,\n          value: nextValue,\n          serializer,\n        });\n      }\n\n      return nextValue;\n    });\n  }, []);\n\n  const remove = useCallback(() => {\n    removeItemFromStorage({\n      key: config.current.key,\n    });\n  }, []);\n\n  const persist = useCallback(() => {\n    const { key, value, serializer } = config.current;\n    setItemInStorage({\n      key,\n      value,\n      serializer,\n    });\n  }, []);\n\n  useEffect(() => {\n    const { defaultValue, deserializer, manual } = config.current;\n    if (manual || !ssr) {\n      return;\n    }\n\n    setValue(\n      getItemFromStorage({\n        key,\n        fallback: defaultValue,\n        deserializer,\n      })\n    );\n  }, [key, ssr, setValue]);\n\n  // update the value if another tab changed the local storage value\n  useEffect(() => {\n    if (!key) {\n      return;\n    }\n\n    const callback = (event: StorageEvent): void => {\n      const { defaultValue, deserializer } = config.current;\n      if (event.key === key) {\n        setStoredValue(\n          getItemFromStorage({\n            key,\n            fallback: defaultValue,\n            deserializer,\n          })\n        );\n      }\n    };\n\n    window.addEventListener(\"storage\", callback);\n    return () => {\n      window.removeEventListener(\"storage\", callback);\n    };\n  }, [key]);\n\n  return {\n    value,\n    setValue,\n    remove,\n    persist,\n  };\n}\n"],"names":["useCallback","useEffect","useRef","useState","useSsr","useIsomorphicLayoutEffect","identity","defaultLocalStorageSerializer","value","getItemFromStorage","options","key","fallback","storage","localStorage","deserializer","JSON","parse","getItem","e","setItemInStorage","serializer","stringify","setItem","removeItemFromStorage","removeItem","useLocalStorage","defaultValue","manual","initialValue","raw","ssr","setStoredValue","config","current","setValue","valueOrDispatcher","prevValue","nextValue","Function","remove","persist","callback","event","window","addEventListener","removeEventListener"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/useOrientation.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useOrientation.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useState } from \"react\";\n\n/**\n * An extremely simple \"polyfill\" for the `window.screen.orientation` just for\n * the `type` value that is required for the `useOrientation` hook.\n *\n * @see {@link https://caniuse.com/screen-orientation}\n * @returns the orientation type either from the `window.screen.orientation` or\n * by comparing the `availHeight` and `availWidth` on the `window.screen`\n * @internal\n */\nexport const getOrientationType = (): OrientationType => {\n  if (typeof window === \"undefined\") {\n    return \"landscape-primary\";\n  }\n\n  // Note: at the time of writing this, it looks like only Safari does not\n  // support it from my list of browsers\n  const screenOrientation = window.screen.orientation?.type;\n  if (typeof screenOrientation === \"string\") {\n    return screenOrientation;\n  }\n\n  const { availHeight, availWidth } = window.screen;\n\n  return availHeight > availWidth ? \"portrait-primary\" : \"landscape-primary\";\n};\n\n/**\n * This hook uses the {@link https://developer.mozilla.org/en-US/docs/Web/API/ScreenOrientation} API\n * to determine if the screen is landscape or portrait. For browsers that do not\n * support this API yet, it will polyfill that behavior using a resize handler\n * instead.\n *\n * @internal\n * @see {@link https://caniuse.com/screen-orientation}\n * @returns the current orientation type\n */\nexport function useOrientation(): OrientationType {\n  const [orientation, setOrientation] = useState(getOrientationType);\n  useEffect(() => {\n    const handler = (): void => setOrientation(getOrientationType());\n\n    const { orientation } = window.screen;\n    if (orientation) {\n      orientation.addEventListener(\"change\", handler);\n    } else {\n      window.addEventListener(\"resize\", handler);\n    }\n\n    return () => {\n      if (orientation) {\n        orientation.removeEventListener(\"change\", handler);\n      } else {\n        window.removeEventListener(\"resize\", handler);\n      }\n    };\n  }, []);\n\n  return orientation;\n}\n"],"names":["useEffect","useState","getOrientationType","window","screenOrientation","screen","orientation","type","availHeight","availWidth","useOrientation","setOrientation","handler","addEventListener","removeEventListener"],"mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAE5C;;;;;;;;CAQC,GACD,OAAO,MAAMC,qBAAqB;IAChC,IAAI,OAAOC,WAAW,aAAa;QACjC,OAAO;IACT;IAEA,wEAAwE;IACxE,sCAAsC;IACtC,MAAMC,oBAAoBD,OAAOE,MAAM,CAACC,WAAW,EAAEC;IACrD,IAAI,OAAOH,sBAAsB,UAAU;QACzC,OAAOA;IACT;IAEA,MAAM,EAAEI,WAAW,EAAEC,UAAU,EAAE,GAAGN,OAAOE,MAAM;IAEjD,OAAOG,cAAcC,aAAa,qBAAqB;AACzD,EAAE;AAEF;;;;;;;;;CASC,GACD,OAAO,SAASC;IACd,MAAM,CAACJ,aAAaK,eAAe,GAAGV,SAASC;IAC/CF,UAAU;QACR,MAAMY,UAAU,IAAYD,eAAeT;QAE3C,MAAM,EAAEI,WAAW,EAAE,GAAGH,OAAOE,MAAM;QACrC,IAAIC,aAAa;YACfA,YAAYO,gBAAgB,CAAC,UAAUD;QACzC,OAAO;YACLT,OAAOU,gBAAgB,CAAC,UAAUD;QACpC;QAEA,OAAO;YACL,IAAIN,aAAa;gBACfA,YAAYQ,mBAAmB,CAAC,UAAUF;YAC5C,OAAO;gBACLT,OAAOW,mBAAmB,CAAC,UAAUF;YACvC;QACF;IACF,GAAG,EAAE;IAEL,OAAON;AACT"}
+{"version":3,"sources":["../src/useOrientation.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useState } from \"react\";\n\n/**\n * An extremely simple \"polyfill\" for the `window.screen.orientation` just for\n * the `type` value that is required for the `useOrientation` hook.\n *\n * @see {@link https://caniuse.com/screen-orientation}\n * @returns the orientation type either from the `window.screen.orientation` or\n * by comparing the `availHeight` and `availWidth` on the `window.screen`\n * @internal\n */\nexport const getOrientationType = (): OrientationType => {\n  if (typeof window === \"undefined\") {\n    return \"landscape-primary\";\n  }\n\n  // Note: at the time of writing this, it looks like only Safari does not\n  // support it from my list of browsers\n  const screenOrientation = window.screen.orientation?.type;\n  if (typeof screenOrientation === \"string\") {\n    return screenOrientation;\n  }\n\n  const { availHeight, availWidth } = window.screen;\n\n  return availHeight > availWidth ? \"portrait-primary\" : \"landscape-primary\";\n};\n\n/**\n * This hook uses the {@link https://developer.mozilla.org/en-US/docs/Web/API/ScreenOrientation} API\n * to determine if the screen is landscape or portrait. For browsers that do not\n * support this API yet, it will polyfill that behavior using a resize handler\n * instead.\n *\n * @internal\n * @see {@link https://caniuse.com/screen-orientation}\n * @returns the current orientation type\n */\nexport function useOrientation(): OrientationType {\n  const [orientation, setOrientation] = useState(getOrientationType);\n  useEffect(() => {\n    const handler = (): void => setOrientation(getOrientationType());\n\n    const { orientation } = window.screen;\n    if (orientation) {\n      orientation.addEventListener(\"change\", handler);\n    } else {\n      window.addEventListener(\"resize\", handler);\n    }\n\n    return () => {\n      if (orientation) {\n        orientation.removeEventListener(\"change\", handler);\n      } else {\n        window.removeEventListener(\"resize\", handler);\n      }\n    };\n  }, []);\n\n  return orientation;\n}\n"],"names":["useEffect","useState","getOrientationType","window","screenOrientation","screen","orientation","type","availHeight","availWidth","useOrientation","setOrientation","handler","addEventListener","removeEventListener"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAE5C;;;;;;;;CAQC,GACD,OAAO,MAAMC,qBAAqB;IAChC,IAAI,OAAOC,WAAW,aAAa;QACjC,OAAO;IACT;IAEA,wEAAwE;IACxE,sCAAsC;IACtC,MAAMC,oBAAoBD,OAAOE,MAAM,CAACC,WAAW,EAAEC;IACrD,IAAI,OAAOH,sBAAsB,UAAU;QACzC,OAAOA;IACT;IAEA,MAAM,EAAEI,WAAW,EAAEC,UAAU,EAAE,GAAGN,OAAOE,MAAM;IAEjD,OAAOG,cAAcC,aAAa,qBAAqB;AACzD,EAAE;AAEF;;;;;;;;;CASC,GACD,OAAO,SAASC;IACd,MAAM,CAACJ,aAAaK,eAAe,GAAGV,SAASC;IAC/CF,UAAU;QACR,MAAMY,UAAU,IAAYD,eAAeT;QAE3C,MAAM,EAAEI,WAAW,EAAE,GAAGH,OAAOE,MAAM;QACrC,IAAIC,aAAa;YACfA,YAAYO,gBAAgB,CAAC,UAAUD;QACzC,OAAO;YACLT,OAAOU,gBAAgB,CAAC,UAAUD;QACpC;QAEA,OAAO;YACL,IAAIN,aAAa;gBACfA,YAAYQ,mBAAmB,CAAC,UAAUF;YAC5C,OAAO;gBACLT,OAAOW,mBAAmB,CAAC,UAAUF;YACvC;QACF;IACF,GAAG,EAAE;IAEL,OAAON;AACT"}

package/dist/usePageInactive.d.ts

@@ -6,11 +6,11 @@
  * browser is no longer partially visible or becomes partially visible.
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilityState
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export type PageInactiveType = "focus" | "visibility";
 /**
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export interface PageInactiveOptions {
     /**
@@ -68,6 +68,6 @@ export interface PageInactiveOptions {
  *   return null;
  * }
  * ```
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export declare function usePageInactive(options: PageInactiveOptions): void;

package/dist/usePageInactive.js

@@ -33,7 +33,7 @@ const noop = ()=>{
  *   return null;
  * }
  * ```
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */ export function usePageInactive(options) {
     const { type = "focus", disabled, onChange, onDisabledCleanup = noop } = options;
     useEffect(()=>{

package/dist/usePageInactive.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/usePageInactive.ts"],"sourcesContent":["\"use client\";\nimport { useEffect } from \"react\";\n\nconst noop = (): void => {\n  // do nothing\n};\n\n/**\n * When this is set to `\"focus\"`, the change handler will be fired whenever the\n * window gains or loses focus.\n *\n * When this is set to `visibility`, the change handler will be fired when the\n * browser is no longer partially visible or becomes partially visible.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilityState\n * @remarks \\@since 6.0.0\n */\nexport type PageInactiveType = \"focus\" | \"visibility\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface PageInactiveOptions {\n  /**\n   * @see {@link PageInactiveType}\n   * @defaultValue `\"focus\"`\n   */\n  type?: PageInactiveType;\n\n  /**\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * This will be called whenever the page activity changes based on the\n   * {@link PageInactiveType}.\n   */\n  onChange(active: boolean): void;\n\n  /**\n   * This will be fired whenever the {@link disabled} state is `true` which can\n   * be useful for clearing pending timers or resetting state.\n   *\n   * Since this is passed to a `useEffect` as a dependency, you might have to\n   * wrap this in a `useCallback` if unexpected re-rendering or errors occurs.\n   *\n   * @defaultValue `() => {}`\n   */\n  onDisabledCleanup?(): void;\n}\n\n/**\n * @example\n * ```ts\n * import { usePageInactive } from \"@react-md/core\";\n * import { useCallback, useEffect, useRef, useState } from \"react\";\n *\n * function Example(): null {\n *   const [visible, setVisible] = useState(false);\n *   const timeout = useRef<number | undefined>();\n *   const startTimeout = useCallback(() => {\n *     timeout.current = window.setTimeout(() => {\n *       setVisible(false);\n *     }, 10000);\n *   }, []);\n *\n *   usePageInactive({\n *     onChange(active) {\n *       if (!active) {\n *         window.clearTimeout(timeout.current);\n *         setVisible(false);\n *       } else {\n *         startTimeout();\n *       }\n *     }\n *   });\n *\n *   // pretend implementation\n *   return null;\n * }\n * ```\n * @remarks \\@since 6.0.0\n */\nexport function usePageInactive(options: PageInactiveOptions): void {\n  const {\n    type = \"focus\",\n    disabled,\n    onChange,\n    onDisabledCleanup = noop,\n  } = options;\n  useEffect(() => {\n    if (disabled) {\n      onDisabledCleanup();\n      return;\n    }\n\n    const callback = (event: Event): void => {\n      let active = document.visibilityState === \"visible\";\n      if (event.type === \"blur\") {\n        active = false;\n      } else if (event.type === \"focus\") {\n        active = true;\n      }\n\n      onChange(active);\n    };\n\n    document.addEventListener(\"visibilitychange\", callback);\n    if (type === \"focus\") {\n      window.addEventListener(\"blur\", callback);\n      window.addEventListener(\"focus\", callback);\n    }\n\n    return () => {\n      document.removeEventListener(\"visibilitychange\", callback);\n      window.removeEventListener(\"blur\", callback);\n      window.removeEventListener(\"focus\", callback);\n    };\n  }, [disabled, onChange, onDisabledCleanup, type]);\n}\n"],"names":["useEffect","noop","usePageInactive","options","type","disabled","onChange","onDisabledCleanup","callback","event","active","document","visibilityState","addEventListener","window","removeEventListener"],"mappings":"AAAA;AACA,SAASA,SAAS,QAAQ,QAAQ;AAElC,MAAMC,OAAO;AACX,aAAa;AACf;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BC,GACD,OAAO,SAASC,gBAAgBC,OAA4B;IAC1D,MAAM,EACJC,OAAO,OAAO,EACdC,QAAQ,EACRC,QAAQ,EACRC,oBAAoBN,IAAI,EACzB,GAAGE;IACJH,UAAU;QACR,IAAIK,UAAU;YACZE;YACA;QACF;QAEA,MAAMC,WAAW,CAACC;YAChB,IAAIC,SAASC,SAASC,eAAe,KAAK;YAC1C,IAAIH,MAAML,IAAI,KAAK,QAAQ;gBACzBM,SAAS;YACX,OAAO,IAAID,MAAML,IAAI,KAAK,SAAS;gBACjCM,SAAS;YACX;YAEAJ,SAASI;QACX;QAEAC,SAASE,gBAAgB,CAAC,oBAAoBL;QAC9C,IAAIJ,SAAS,SAAS;YACpBU,OAAOD,gBAAgB,CAAC,QAAQL;YAChCM,OAAOD,gBAAgB,CAAC,SAASL;QACnC;QAEA,OAAO;YACLG,SAASI,mBAAmB,CAAC,oBAAoBP;YACjDM,OAAOC,mBAAmB,CAAC,QAAQP;YACnCM,OAAOC,mBAAmB,CAAC,SAASP;QACtC;IACF,GAAG;QAACH;QAAUC;QAAUC;QAAmBH;KAAK;AAClD"}
+{"version":3,"sources":["../src/usePageInactive.ts"],"sourcesContent":["\"use client\";\nimport { useEffect } from \"react\";\n\nconst noop = (): void => {\n  // do nothing\n};\n\n/**\n * When this is set to `\"focus\"`, the change handler will be fired whenever the\n * window gains or loses focus.\n *\n * When this is set to `visibility`, the change handler will be fired when the\n * browser is no longer partially visible or becomes partially visible.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilityState\n * @since 6.0.0\n */\nexport type PageInactiveType = \"focus\" | \"visibility\";\n\n/**\n * @since 6.0.0\n */\nexport interface PageInactiveOptions {\n  /**\n   * @see {@link PageInactiveType}\n   * @defaultValue `\"focus\"`\n   */\n  type?: PageInactiveType;\n\n  /**\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * This will be called whenever the page activity changes based on the\n   * {@link PageInactiveType}.\n   */\n  onChange(active: boolean): void;\n\n  /**\n   * This will be fired whenever the {@link disabled} state is `true` which can\n   * be useful for clearing pending timers or resetting state.\n   *\n   * Since this is passed to a `useEffect` as a dependency, you might have to\n   * wrap this in a `useCallback` if unexpected re-rendering or errors occurs.\n   *\n   * @defaultValue `() => {}`\n   */\n  onDisabledCleanup?(): void;\n}\n\n/**\n * @example\n * ```ts\n * import { usePageInactive } from \"@react-md/core\";\n * import { useCallback, useEffect, useRef, useState } from \"react\";\n *\n * function Example(): null {\n *   const [visible, setVisible] = useState(false);\n *   const timeout = useRef<number | undefined>();\n *   const startTimeout = useCallback(() => {\n *     timeout.current = window.setTimeout(() => {\n *       setVisible(false);\n *     }, 10000);\n *   }, []);\n *\n *   usePageInactive({\n *     onChange(active) {\n *       if (!active) {\n *         window.clearTimeout(timeout.current);\n *         setVisible(false);\n *       } else {\n *         startTimeout();\n *       }\n *     }\n *   });\n *\n *   // pretend implementation\n *   return null;\n * }\n * ```\n * @since 6.0.0\n */\nexport function usePageInactive(options: PageInactiveOptions): void {\n  const {\n    type = \"focus\",\n    disabled,\n    onChange,\n    onDisabledCleanup = noop,\n  } = options;\n  useEffect(() => {\n    if (disabled) {\n      onDisabledCleanup();\n      return;\n    }\n\n    const callback = (event: Event): void => {\n      let active = document.visibilityState === \"visible\";\n      if (event.type === \"blur\") {\n        active = false;\n      } else if (event.type === \"focus\") {\n        active = true;\n      }\n\n      onChange(active);\n    };\n\n    document.addEventListener(\"visibilitychange\", callback);\n    if (type === \"focus\") {\n      window.addEventListener(\"blur\", callback);\n      window.addEventListener(\"focus\", callback);\n    }\n\n    return () => {\n      document.removeEventListener(\"visibilitychange\", callback);\n      window.removeEventListener(\"blur\", callback);\n      window.removeEventListener(\"focus\", callback);\n    };\n  }, [disabled, onChange, onDisabledCleanup, type]);\n}\n"],"names":["useEffect","noop","usePageInactive","options","type","disabled","onChange","onDisabledCleanup","callback","event","active","document","visibilityState","addEventListener","window","removeEventListener"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,SAAS,QAAQ,QAAQ;AAElC,MAAMC,OAAO;AACX,aAAa;AACf;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BC,GACD,OAAO,SAASC,gBAAgBC,OAA4B;IAC1D,MAAM,EACJC,OAAO,OAAO,EACdC,QAAQ,EACRC,QAAQ,EACRC,oBAAoBN,IAAI,EACzB,GAAGE;IACJH,UAAU;QACR,IAAIK,UAAU;YACZE;YACA;QACF;QAEA,MAAMC,WAAW,CAACC;YAChB,IAAIC,SAASC,SAASC,eAAe,KAAK;YAC1C,IAAIH,MAAML,IAAI,KAAK,QAAQ;gBACzBM,SAAS;YACX,OAAO,IAAID,MAAML,IAAI,KAAK,SAAS;gBACjCM,SAAS;YACX;YAEAJ,SAASI;QACX;QAEAC,SAASE,gBAAgB,CAAC,oBAAoBL;QAC9C,IAAIJ,SAAS,SAAS;YACpBU,OAAOD,gBAAgB,CAAC,QAAQL;YAChCM,OAAOD,gBAAgB,CAAC,SAASL;QACnC;QAEA,OAAO;YACLG,SAASI,mBAAmB,CAAC,oBAAoBP;YACjDM,OAAOC,mBAAmB,CAAC,QAAQP;YACnCM,OAAOC,mBAAmB,CAAC,SAASP;QACtC;IACF,GAAG;QAACH;QAAUC;QAAUC;QAAmBH;KAAK;AAClD"}

package/dist/useResizeListener.d.ts

@@ -1,5 +1,5 @@
 /**
- * @remarks \@since 6.0.0  Updated the API
+ * @since 6.0.0  Updated the API
  */
 export interface ResizeListenerOptions extends AddEventListenerOptions {
     /**
@@ -26,8 +26,7 @@ export interface ResizeListenerOptions extends AddEventListenerOptions {
  * observe specific elements resizing, check out the {@link useResizeObserver}
  * hook instead.
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useResizeListener } from "@react-md/core";
  * import type { ReactElement } from "react";
@@ -57,7 +56,7 @@ export interface ResizeListenerOptions extends AddEventListenerOptions {
  * }
  * ```
  *
- * @remarks \@since 6.0.0  Updated the API to match the `useResizeObserver` and
+ * @since 6.0.0  Updated the API to match the `useResizeObserver` and
  * `useIntersectionObserver` hooks by having an `onUpdate` callback and include
  * the `AddEventListenerOptions` as part of the hook options.
  */

package/dist/useResizeListener.js

@@ -6,8 +6,7 @@ import { delegateEvent } from "./delegateEvent.js";
  * observe specific elements resizing, check out the {@link useResizeObserver}
  * hook instead.
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useResizeListener } from "@react-md/core";
  * import type { ReactElement } from "react";
@@ -37,7 +36,7 @@ import { delegateEvent } from "./delegateEvent.js";
  * }
  * ```
  *
- * @remarks \@since 6.0.0  Updated the API to match the `useResizeObserver` and
+ * @since 6.0.0  Updated the API to match the `useResizeObserver` and
  * `useIntersectionObserver` hooks by having an `onUpdate` callback and include
  * the `AddEventListenerOptions` as part of the hook options.
  */ export function useResizeListener(options) {

package/dist/useResizeListener.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useResizeListener.ts"],"sourcesContent":["\"use client\";\nimport { useEffect } from \"react\";\nimport { delegateEvent } from \"./delegateEvent.js\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { useResizeObserver } from \"./useResizeObserver.js\";\n\n/**\n * @remarks \\@since 6.0.0  Updated the API\n */\nexport interface ResizeListenerOptions extends AddEventListenerOptions {\n  /**\n   * Set this to `false` to disable throttling with\n   * `window.requestAnimationFrame`.\n   *\n   * @defaultValue `true`\n   */\n  throttle?: boolean;\n\n  /**\n   * Set this to `true` to disable attaching the resize event handler.\n   *\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * This function will be called whenever the resize event is fired on the\n   * `window`. This should be wrapped in `useCallback`.\n   */\n  onUpdate(event: Event): void;\n}\n\n/**\n * This hook can be used to listen to the entire window resizing. If you need to\n * observe specific elements resizing, check out the {@link useResizeObserver}\n * hook instead.\n *\n * @example\n * Simple Example\n * ```tsx\n * import { useResizeListener } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n * import { useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const [size, setSize] = useState({\n *     height: window.innerHeight,\n *     width: window.innerWidth,\n *   }):\n *\n *   useResizeListener({\n *     onUpdate(event) {\n *       setSize({\n *         height: window.innerHeight,\n *         width: window.innerWidth,\n *       });\n *     },\n *   });\n *\n *   return (\n *     <>\n *       The current window size:\n *       <pre><code>{JSON.stringify(size, null, 2)}</code></pre>\n *     </>\n *   );\n * }\n * ```\n *\n * @remarks \\@since 6.0.0  Updated the API to match the `useResizeObserver` and\n * `useIntersectionObserver` hooks by having an `onUpdate` callback and include\n * the `AddEventListenerOptions` as part of the hook options.\n */\nexport function useResizeListener(options: ResizeListenerOptions): void {\n  const {\n    once,\n    signal,\n    capture,\n    passive,\n    throttle = true,\n    disabled = false,\n    onUpdate,\n  } = options;\n\n  useEffect(() => {\n    if (disabled) {\n      return;\n    }\n\n    const eventHandler = delegateEvent(\"resize\", window, throttle, {\n      once,\n      signal,\n      capture,\n      passive,\n    });\n    eventHandler.add(onUpdate);\n\n    window.dispatchEvent(new Event(\"resize\"));\n    return () => {\n      eventHandler.remove(onUpdate);\n    };\n  }, [capture, disabled, onUpdate, once, passive, signal, throttle]);\n}\n"],"names":["useEffect","delegateEvent","useResizeListener","options","once","signal","capture","passive","throttle","disabled","onUpdate","eventHandler","window","add","dispatchEvent","Event","remove"],"mappings":"AAAA;AACA,SAASA,SAAS,QAAQ,QAAQ;AAClC,SAASC,aAAa,QAAQ,qBAAqB;AA8BnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,GACD,OAAO,SAASC,kBAAkBC,OAA8B;IAC9D,MAAM,EACJC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,OAAO,EACPC,WAAW,IAAI,EACfC,WAAW,KAAK,EAChBC,QAAQ,EACT,GAAGP;IAEJH,UAAU;QACR,IAAIS,UAAU;YACZ;QACF;QAEA,MAAME,eAAeV,cAAc,UAAUW,QAAQJ,UAAU;YAC7DJ;YACAC;YACAC;YACAC;QACF;QACAI,aAAaE,GAAG,CAACH;QAEjBE,OAAOE,aAAa,CAAC,IAAIC,MAAM;QAC/B,OAAO;YACLJ,aAAaK,MAAM,CAACN;QACtB;IACF,GAAG;QAACJ;QAASG;QAAUC;QAAUN;QAAMG;QAASF;QAAQG;KAAS;AACnE"}
+{"version":3,"sources":["../src/useResizeListener.ts"],"sourcesContent":["\"use client\";\nimport { useEffect } from \"react\";\nimport { delegateEvent } from \"./delegateEvent.js\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { useResizeObserver } from \"./useResizeObserver.js\";\n\n/**\n * @since 6.0.0  Updated the API\n */\nexport interface ResizeListenerOptions extends AddEventListenerOptions {\n  /**\n   * Set this to `false` to disable throttling with\n   * `window.requestAnimationFrame`.\n   *\n   * @defaultValue `true`\n   */\n  throttle?: boolean;\n\n  /**\n   * Set this to `true` to disable attaching the resize event handler.\n   *\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * This function will be called whenever the resize event is fired on the\n   * `window`. This should be wrapped in `useCallback`.\n   */\n  onUpdate(event: Event): void;\n}\n\n/**\n * This hook can be used to listen to the entire window resizing. If you need to\n * observe specific elements resizing, check out the {@link useResizeObserver}\n * hook instead.\n *\n * @example Simple Example\n * ```tsx\n * import { useResizeListener } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n * import { useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const [size, setSize] = useState({\n *     height: window.innerHeight,\n *     width: window.innerWidth,\n *   }):\n *\n *   useResizeListener({\n *     onUpdate(event) {\n *       setSize({\n *         height: window.innerHeight,\n *         width: window.innerWidth,\n *       });\n *     },\n *   });\n *\n *   return (\n *     <>\n *       The current window size:\n *       <pre><code>{JSON.stringify(size, null, 2)}</code></pre>\n *     </>\n *   );\n * }\n * ```\n *\n * @since 6.0.0  Updated the API to match the `useResizeObserver` and\n * `useIntersectionObserver` hooks by having an `onUpdate` callback and include\n * the `AddEventListenerOptions` as part of the hook options.\n */\nexport function useResizeListener(options: ResizeListenerOptions): void {\n  const {\n    once,\n    signal,\n    capture,\n    passive,\n    throttle = true,\n    disabled = false,\n    onUpdate,\n  } = options;\n\n  useEffect(() => {\n    if (disabled) {\n      return;\n    }\n\n    const eventHandler = delegateEvent(\"resize\", window, throttle, {\n      once,\n      signal,\n      capture,\n      passive,\n    });\n    eventHandler.add(onUpdate);\n\n    window.dispatchEvent(new Event(\"resize\"));\n    return () => {\n      eventHandler.remove(onUpdate);\n    };\n  }, [capture, disabled, onUpdate, once, passive, signal, throttle]);\n}\n"],"names":["useEffect","delegateEvent","useResizeListener","options","once","signal","capture","passive","throttle","disabled","onUpdate","eventHandler","window","add","dispatchEvent","Event","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,SAAS,QAAQ,QAAQ;AAClC,SAASC,aAAa,QAAQ,qBAAqB;AA8BnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCC,GACD,OAAO,SAASC,kBAAkBC,OAA8B;IAC9D,MAAM,EACJC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,OAAO,EACPC,WAAW,IAAI,EACfC,WAAW,KAAK,EAChBC,QAAQ,EACT,GAAGP;IAEJH,UAAU;QACR,IAAIS,UAAU;YACZ;QACF;QAEA,MAAME,eAAeV,cAAc,UAAUW,QAAQJ,UAAU;YAC7DJ;YACAC;YACAC;YACAC;QACF;QACAI,aAAaE,GAAG,CAACH;QAEjBE,OAAOE,aAAa,CAAC,IAAIC,MAAM;QAC/B,OAAO;YACLJ,aAAaK,MAAM,CAACN;QACtB;IACF,GAAG;QAACJ;QAASG;QAAUC;QAAUN;QAAMG;QAASF;QAAQG;KAAS;AACnE"}

package/dist/useResizeObserver.d.ts

@@ -1,6 +1,6 @@
 import { type Ref, type RefCallback } from "react";
 /**
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export type ResizeObserverEntryCallback = (entry: ResizeObserverEntry) => void;
 /** @internal */
@@ -28,7 +28,7 @@ interface SubscribeOptions {
 }
 /**
  * @internal
- * @remarks \@since 6.0.0 This was added to help with testing. The
+ * @since 6.0.0 This was added to help with testing. The
  * `subscriptions` and `sharedObserver` used to be module-level variables but
  * moving to a class makes it easier to mock. Checkout the
  * `src/tests-utils/ResizeObserver.ts`
@@ -52,13 +52,12 @@ export declare class ResizeObserverManager {
 }
 /**
  * @internal
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export declare const resizeObserverManager: ResizeObserverManager;
 /**
- * @remarks
- * \@since 2.3.0
- * \@since 6.0.0 Renamed from `UseResizeObserverOptions` and added
+ * @since 2.3.0
+ * @since 6.0.0 Renamed from `UseResizeObserverOptions` and added
  * `onUpdate`/`disabled` options.
  */
 export interface ResizeObserverHookOptions<E extends HTMLElement> {
@@ -76,7 +75,7 @@ export interface ResizeObserverHookOptions<E extends HTMLElement> {
      */
     onUpdate: ResizeObserverEntryCallback;
     /**
-     * Set this to `true` to prevent observing the element's size changes. THis is
+     * Set this to `true` to prevent observing the element's size changes. This is
      * equivalent to not attaching the returned ref to any element.
      *
      * @defaultValue `false`
@@ -102,9 +101,8 @@ export interface ResizeObserverHookOptions<E extends HTMLElement> {
  * For most cases you can use the {@link useElementSize} instead, but this hook
  * can be used for more complex behavior with the {@link ResizeObserverEntry}.
  *
- * @remarks
- * \@since 2.3.0
- * \@since 6.0.0 The API was updated to match the `useIntersectionObserver`
+ * @since 2.3.0
+ * @since 6.0.0 The API was updated to match the `useIntersectionObserver`
  * implementation -- accepts only a single object parameter and returns a
  * {@link RefCallback} instead of `[nodeRef, refCallback]`
  */

package/dist/useResizeObserver.js

@@ -16,7 +16,7 @@ import { useEffect } from "react";
 import { useEnsuredRef } from "./useEnsuredRef.js";
 /**
  * @internal
- * @remarks \@since 6.0.0 This was added to help with testing. The
+ * @since 6.0.0 This was added to help with testing. The
  * `subscriptions` and `sharedObserver` used to be module-level variables but
  * moving to a class makes it easier to mock. Checkout the
  * `src/tests-utils/ResizeObserver.ts`
@@ -92,16 +92,15 @@ import { useEnsuredRef } from "./useEnsuredRef.js";
 }
 /**
  * @internal
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */ export const resizeObserverManager = new ResizeObserverManager();
 /**
  * The resize observer is used to track the size changes of a specific element.
  * For most cases you can use the {@link useElementSize} instead, but this hook
  * can be used for more complex behavior with the {@link ResizeObserverEntry}.
  *
- * @remarks
- * \@since 2.3.0
- * \@since 6.0.0 The API was updated to match the `useIntersectionObserver`
+ * @since 2.3.0
+ * @since 6.0.0 The API was updated to match the `useIntersectionObserver`
  * implementation -- accepts only a single object parameter and returns a
  * {@link RefCallback} instead of `[nodeRef, refCallback]`
  */ export function useResizeObserver(options) {

package/dist/useResizeObserver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useResizeObserver.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, type Ref, type RefCallback } from \"react\";\nimport { useEnsuredRef } from \"./useEnsuredRef.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { type useElementSize } from \"./useElementSize.js\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport type ResizeObserverEntryCallback = (entry: ResizeObserverEntry) => void;\n\n/** @internal */\ntype Unsubscribe = () => void;\n\n/** @internal */\ninterface TargetSize {\n  height: number;\n  width: number;\n  scrollHeight: number;\n  scrollWidth: number;\n}\n\n/** @internal */\ninterface TargetSubscription {\n  readonly onUpdate: ResizeObserverEntryCallback;\n  readonly disableHeight: boolean;\n  readonly disableWidth: boolean;\n\n  size?: TargetSize;\n}\n\n/** @internal */\ninterface SubscribeOptions {\n  element: Element;\n  onUpdate: ResizeObserverEntryCallback;\n  disableHeight: boolean;\n  disableWidth: boolean;\n}\n\n/**\n * @internal\n * @remarks \\@since 6.0.0 This was added to help with testing. The\n * `subscriptions` and `sharedObserver` used to be module-level variables but\n * moving to a class makes it easier to mock. Checkout the\n * `src/tests-utils/ResizeObserver.ts`\n */\nexport class ResizeObserverManager {\n  frame: number;\n  subscriptions: Map<Element, Set<TargetSubscription>>;\n\n  /**\n   * Why is there a single shared observer instead of multiple and a\n   * \"subscription\" model?\n   *\n   * Note: Probably a bit of a premature optimization right now...\n   *\n   * @see https://github.com/WICG/resize-observer/issues/59\n   * @internal\n   */\n  sharedObserver: ResizeObserver | undefined;\n\n  constructor() {\n    this.frame = 0;\n    this.subscriptions = new Map();\n  }\n\n  subscribe = (options: SubscribeOptions): Unsubscribe => {\n    const { element, onUpdate, disableHeight, disableWidth } = options;\n\n    // lazy initialize the observer\n    const observer =\n      this.sharedObserver ||\n      new ResizeObserver((entries) => {\n        // this prevents the `ResizeObserver loop limit exceeded`\n        window.cancelAnimationFrame(this.frame);\n        this.frame = window.requestAnimationFrame(() => {\n          this.handleResizeEntries(entries);\n        });\n      });\n    this.sharedObserver = observer;\n\n    const updates = this.subscriptions.get(element) || new Set();\n    const subscription: TargetSubscription = {\n      onUpdate,\n      disableHeight,\n      disableWidth,\n    };\n    updates.add(subscription);\n    if (!this.subscriptions.has(element)) {\n      this.subscriptions.set(element, updates);\n    }\n\n    observer.observe(element);\n\n    return () => {\n      observer.unobserve(element);\n      updates.delete(subscription);\n    };\n  };\n\n  handleResizeEntries = (entries: ResizeObserverEntry[]): void => {\n    for (const entry of entries) {\n      const targetSubscriptions = this.subscriptions.get(entry.target);\n      // shouldn't really happen\n      /* c8 ignore start */\n      if (!targetSubscriptions) {\n        continue;\n      }\n      /* c8 ignore stop */\n\n      const entries = targetSubscriptions.values();\n      for (const subscription of entries) {\n        const { height, width } = entry.contentRect;\n        const { scrollHeight, scrollWidth } = entry.target;\n        const { onUpdate, size, disableHeight, disableWidth } = subscription;\n        const isHeightChange =\n          !disableHeight &&\n          (!size ||\n            size.height !== height ||\n            size.scrollHeight !== scrollHeight);\n        const isWidthChange =\n          !disableWidth &&\n          (!size || size.width !== width || size.scrollWidth !== scrollWidth);\n\n        subscription.size = {\n          height,\n          width,\n          scrollHeight,\n          scrollWidth,\n        };\n        if (isHeightChange || isWidthChange) {\n          onUpdate(entry);\n        }\n      }\n    }\n  };\n}\n\n/**\n * @internal\n * @remarks \\@since 6.0.0\n */\nexport const resizeObserverManager = new ResizeObserverManager();\n\n/**\n * @remarks\n * \\@since 2.3.0\n * \\@since 6.0.0 Renamed from `UseResizeObserverOptions` and added\n * `onUpdate`/`disabled` options.\n */\nexport interface ResizeObserverHookOptions<E extends HTMLElement> {\n  /**\n   * An optional ref to merge with the ref returned by this hook.\n   */\n  ref?: Ref<E>;\n\n  /**\n   * **Must be wrapped in `useCallback` to prevent re-creating the\n   * ResizeObserver each render.**\n   *\n   * This function will be called whenever the target element resizes.\n   *\n   * @see {@link useResizeObserver} for an example.\n   */\n  onUpdate: ResizeObserverEntryCallback;\n\n  /**\n   * Set this to `true` to prevent observing the element's size changes. THis is\n   * equivalent to not attaching the returned ref to any element.\n   *\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * Set this to `true` if the {@link onUpdate} should not be fired for height\n   * changes.\n   *\n   * @defaultValue `false`\n   */\n  disableHeight?: boolean;\n\n  /**\n   * Set this to `true` if the {@link onUpdate} should not be fired for width\n   * changes.\n   *\n   * @defaultValue `false`\n   */\n  disableWidth?: boolean;\n}\n\n/**\n * The resize observer is used to track the size changes of a specific element.\n * For most cases you can use the {@link useElementSize} instead, but this hook\n * can be used for more complex behavior with the {@link ResizeObserverEntry}.\n *\n * @remarks\n * \\@since 2.3.0\n * \\@since 6.0.0 The API was updated to match the `useIntersectionObserver`\n * implementation -- accepts only a single object parameter and returns a\n * {@link RefCallback} instead of `[nodeRef, refCallback]`\n */\nexport function useResizeObserver<E extends HTMLElement>(\n  options: ResizeObserverHookOptions<E>\n): RefCallback<E> {\n  const {\n    ref,\n    onUpdate,\n    disabled,\n    disableHeight = false,\n    disableWidth = false,\n  } = options;\n\n  const [targetNodeRef, refCallback] = useEnsuredRef(ref);\n  useEffect(() => {\n    const element = targetNodeRef.current;\n    if (disabled || (disableHeight && disableWidth) || !element) {\n      return;\n    }\n\n    const unsubscribe = resizeObserverManager.subscribe({\n      element,\n      onUpdate,\n      disableHeight,\n      disableWidth,\n    });\n\n    return () => {\n      unsubscribe();\n    };\n  }, [disableHeight, disableWidth, disabled, onUpdate, targetNodeRef]);\n\n  return refCallback;\n}\n"],"names":["useEffect","useEnsuredRef","ResizeObserverManager","constructor","frame","subscriptions","sharedObserver","subscribe","options","element","onUpdate","disableHeight","disableWidth","observer","ResizeObserver","entries","window","cancelAnimationFrame","requestAnimationFrame","handleResizeEntries","updates","get","Set","subscription","add","has","set","observe","unobserve","delete","entry","targetSubscriptions","target","values","height","width","contentRect","scrollHeight","scrollWidth","size","isHeightChange","isWidthChange","Map","resizeObserverManager","useResizeObserver","ref","disabled","targetNodeRef","refCallback","current","unsubscribe"],"mappings":"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"}
+{"version":3,"sources":["../src/useResizeObserver.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, type Ref, type RefCallback } from \"react\";\nimport { useEnsuredRef } from \"./useEnsuredRef.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { type useElementSize } from \"./useElementSize.js\";\n\n/**\n * @since 6.0.0\n */\nexport type ResizeObserverEntryCallback = (entry: ResizeObserverEntry) => void;\n\n/** @internal */\ntype Unsubscribe = () => void;\n\n/** @internal */\ninterface TargetSize {\n  height: number;\n  width: number;\n  scrollHeight: number;\n  scrollWidth: number;\n}\n\n/** @internal */\ninterface TargetSubscription {\n  readonly onUpdate: ResizeObserverEntryCallback;\n  readonly disableHeight: boolean;\n  readonly disableWidth: boolean;\n\n  size?: TargetSize;\n}\n\n/** @internal */\ninterface SubscribeOptions {\n  element: Element;\n  onUpdate: ResizeObserverEntryCallback;\n  disableHeight: boolean;\n  disableWidth: boolean;\n}\n\n/**\n * @internal\n * @since 6.0.0 This was added to help with testing. The\n * `subscriptions` and `sharedObserver` used to be module-level variables but\n * moving to a class makes it easier to mock. Checkout the\n * `src/tests-utils/ResizeObserver.ts`\n */\nexport class ResizeObserverManager {\n  frame: number;\n  subscriptions: Map<Element, Set<TargetSubscription>>;\n\n  /**\n   * Why is there a single shared observer instead of multiple and a\n   * \"subscription\" model?\n   *\n   * Note: Probably a bit of a premature optimization right now...\n   *\n   * @see https://github.com/WICG/resize-observer/issues/59\n   * @internal\n   */\n  sharedObserver: ResizeObserver | undefined;\n\n  constructor() {\n    this.frame = 0;\n    this.subscriptions = new Map();\n  }\n\n  subscribe = (options: SubscribeOptions): Unsubscribe => {\n    const { element, onUpdate, disableHeight, disableWidth } = options;\n\n    // lazy initialize the observer\n    const observer =\n      this.sharedObserver ||\n      new ResizeObserver((entries) => {\n        // this prevents the `ResizeObserver loop limit exceeded`\n        window.cancelAnimationFrame(this.frame);\n        this.frame = window.requestAnimationFrame(() => {\n          this.handleResizeEntries(entries);\n        });\n      });\n    this.sharedObserver = observer;\n\n    const updates = this.subscriptions.get(element) || new Set();\n    const subscription: TargetSubscription = {\n      onUpdate,\n      disableHeight,\n      disableWidth,\n    };\n    updates.add(subscription);\n    if (!this.subscriptions.has(element)) {\n      this.subscriptions.set(element, updates);\n    }\n\n    observer.observe(element);\n\n    return () => {\n      observer.unobserve(element);\n      updates.delete(subscription);\n    };\n  };\n\n  handleResizeEntries = (entries: ResizeObserverEntry[]): void => {\n    for (const entry of entries) {\n      const targetSubscriptions = this.subscriptions.get(entry.target);\n      // shouldn't really happen\n      /* c8 ignore start */\n      if (!targetSubscriptions) {\n        continue;\n      }\n      /* c8 ignore stop */\n\n      const entries = targetSubscriptions.values();\n      for (const subscription of entries) {\n        const { height, width } = entry.contentRect;\n        const { scrollHeight, scrollWidth } = entry.target;\n        const { onUpdate, size, disableHeight, disableWidth } = subscription;\n        const isHeightChange =\n          !disableHeight &&\n          (!size ||\n            size.height !== height ||\n            size.scrollHeight !== scrollHeight);\n        const isWidthChange =\n          !disableWidth &&\n          (!size || size.width !== width || size.scrollWidth !== scrollWidth);\n\n        subscription.size = {\n          height,\n          width,\n          scrollHeight,\n          scrollWidth,\n        };\n        if (isHeightChange || isWidthChange) {\n          onUpdate(entry);\n        }\n      }\n    }\n  };\n}\n\n/**\n * @internal\n * @since 6.0.0\n */\nexport const resizeObserverManager = new ResizeObserverManager();\n\n/**\n * @since 2.3.0\n * @since 6.0.0 Renamed from `UseResizeObserverOptions` and added\n * `onUpdate`/`disabled` options.\n */\nexport interface ResizeObserverHookOptions<E extends HTMLElement> {\n  /**\n   * An optional ref to merge with the ref returned by this hook.\n   */\n  ref?: Ref<E>;\n\n  /**\n   * **Must be wrapped in `useCallback` to prevent re-creating the\n   * ResizeObserver each render.**\n   *\n   * This function will be called whenever the target element resizes.\n   *\n   * @see {@link useResizeObserver} for an example.\n   */\n  onUpdate: ResizeObserverEntryCallback;\n\n  /**\n   * Set this to `true` to prevent observing the element's size changes. This is\n   * equivalent to not attaching the returned ref to any element.\n   *\n   * @defaultValue `false`\n   */\n  disabled?: boolean;\n\n  /**\n   * Set this to `true` if the {@link onUpdate} should not be fired for height\n   * changes.\n   *\n   * @defaultValue `false`\n   */\n  disableHeight?: boolean;\n\n  /**\n   * Set this to `true` if the {@link onUpdate} should not be fired for width\n   * changes.\n   *\n   * @defaultValue `false`\n   */\n  disableWidth?: boolean;\n}\n\n/**\n * The resize observer is used to track the size changes of a specific element.\n * For most cases you can use the {@link useElementSize} instead, but this hook\n * can be used for more complex behavior with the {@link ResizeObserverEntry}.\n *\n * @since 2.3.0\n * @since 6.0.0 The API was updated to match the `useIntersectionObserver`\n * implementation -- accepts only a single object parameter and returns a\n * {@link RefCallback} instead of `[nodeRef, refCallback]`\n */\nexport function useResizeObserver<E extends HTMLElement>(\n  options: ResizeObserverHookOptions<E>\n): RefCallback<E> {\n  const {\n    ref,\n    onUpdate,\n    disabled,\n    disableHeight = false,\n    disableWidth = false,\n  } = options;\n\n  const [targetNodeRef, refCallback] = useEnsuredRef(ref);\n  useEffect(() => {\n    const element = targetNodeRef.current;\n    if (disabled || (disableHeight && disableWidth) || !element) {\n      return;\n    }\n\n    const unsubscribe = resizeObserverManager.subscribe({\n      element,\n      onUpdate,\n      disableHeight,\n      disableWidth,\n    });\n\n    return () => {\n      unsubscribe();\n    };\n  }, [disableHeight, disableWidth, disabled, onUpdate, targetNodeRef]);\n\n  return refCallback;\n}\n"],"names":["useEffect","useEnsuredRef","ResizeObserverManager","constructor","frame","subscriptions","sharedObserver","subscribe","options","element","onUpdate","disableHeight","disableWidth","observer","ResizeObserver","entries","window","cancelAnimationFrame","requestAnimationFrame","handleResizeEntries","updates","get","Set","subscription","add","has","set","observe","unobserve","delete","entry","targetSubscriptions","target","values","height","width","contentRect","scrollHeight","scrollWidth","size","isHeightChange","isWidthChange","Map","resizeObserverManager","useResizeObserver","ref","disabled","targetNodeRef","refCallback","current","unsubscribe"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/useThrottledFunction.d.ts

@@ -1,13 +1,12 @@
 import { type AnyFunction, type CancelableFunction } from "./types.js";
 /**
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export type ThrottledFunction<F extends AnyFunction> = CancelableFunction<(...args: Parameters<F>) => ReturnType<F>>;
 /**
  * Creates a function that will only be called once every X milliseconds.
  *
- * @example
- * Throttling Search API Requests
+ * @example Throttling Search API Requests
  * ```tsx
  * import { TextField, useThrottledFunction, useUnmounted } from "@react-md/core";
  * import { useState } from "react";
@@ -77,6 +76,6 @@ export type ThrottledFunction<F extends AnyFunction> = CancelableFunction<(...ar
  *
  * @see `useDebouncedFunction` for debounce behavior instead. (Call a
  * function only if it has not been called again for X milliseconds).
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export declare function useThrottledFunction<F extends AnyFunction>(func: F, wait: number): ThrottledFunction<F>;

package/dist/useThrottledFunction.js

@@ -4,8 +4,7 @@ import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
 /**
  * Creates a function that will only be called once every X milliseconds.
  *
- * @example
- * Throttling Search API Requests
+ * @example Throttling Search API Requests
  * ```tsx
  * import { TextField, useThrottledFunction, useUnmounted } from "@react-md/core";
  * import { useState } from "react";
@@ -75,7 +74,7 @@ import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
  *
  * @see `useDebouncedFunction` for debounce behavior instead. (Call a
  * function only if it has not been called again for X milliseconds).
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */ export function useThrottledFunction(func, wait) {
     const args = useRef();
     const result = useRef();

package/dist/useThrottledFunction.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useThrottledFunction.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { type AnyFunction, type CancelableFunction } from \"./types.js\";\nimport { useIsomorphicLayoutEffect } from \"./useIsomorphicLayoutEffect.js\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport type ThrottledFunction<F extends AnyFunction> = CancelableFunction<\n  (...args: Parameters<F>) => ReturnType<F>\n>;\n\n/**\n * Creates a function that will only be called once every X milliseconds.\n *\n * @example\n * Throttling Search API Requests\n * ```tsx\n * import { TextField, useThrottledFunction, useUnmounted } from \"@react-md/core\";\n * import { useState } from \"react\";\n * import type { ReactElement } from \"react\";\n *\n * interface State {\n *   error?: unknown\n *   loading: boolean;\n *   results?: {\n *     // pretend some search results\n *     id: string;\n *     name: string;\n *   }[];\n * }\n *\n * function Example(): ReactElement {\n *   const [state, setState] = useState<State>({\n *     loading: false,\n *   });\n *   // this is only required for async actions\n *   const unmounted = useUnmounted();\n *\n *   // A new search request will be fired once every 500ms as the user types.\n *   // can't use the event here since React uses synthetic events\n *   const search = useThrottledFunction(async (q: string) => {\n *     setState({\n *       loading: true,\n *       error: undefined,\n *       results: undefined,\n *     });\n *\n *     try {\n *       const response = await fetch('/search', {\n *         method: 'POST',\n *         headers: {\n *           'Content-Type': 'application/json',\n *         },\n *         body: JSON.stringify({ q }),\n *       });\n *       const json = await response.json();\n *\n *       if (!unmounted.current) {\n *         setState({\n *           loading: false,\n *           results: json,\n *         });\n *       }\n *     } catch (error) {\n *       if (!unmounted.current) {\n *         setState({\n *           error,\n *           loading: false,\n *         });\n *       }\n *     }\n *   }, 500);\n *\n *   return (\n *     <TextField\n *       type=\"search\"\n *       label=\"Search\"\n *       onChange={(event) => search(event.currentTarget.value)}\n *     />\n *   );\n * }\n * ```\n *\n * @see `useDebouncedFunction` for debounce behavior instead. (Call a\n * function only if it has not been called again for X milliseconds).\n * @remarks \\@since 6.0.0\n */\nexport function useThrottledFunction<F extends AnyFunction>(\n  func: F,\n  wait: number\n): ThrottledFunction<F> {\n  const args = useRef<Parameters<F>>();\n  const result = useRef<ReturnType<F>>();\n  const timeout = useRef<number | undefined>();\n  const funcRef = useRef(func);\n  const lastCalledTime = useRef(0);\n\n  useIsomorphicLayoutEffect(() => {\n    funcRef.current = func;\n  });\n\n  useEffect(() => {\n    return () => {\n      window.clearTimeout(timeout.current);\n    };\n  }, []);\n\n  return useMemo(() => {\n    const throttled: ThrottledFunction<F> = (...nextArgs) => {\n      args.current = nextArgs;\n\n      const now = Date.now();\n      const remaining = wait - (now - lastCalledTime.current);\n      if (remaining <= 0 || remaining > wait) {\n        lastCalledTime.current = now;\n        result.current = funcRef.current(...args.current);\n      } else if (!timeout.current) {\n        timeout.current = window.setTimeout(() => {\n          lastCalledTime.current = Date.now();\n          timeout.current = undefined;\n          // should exist by this time\n          result.current = funcRef.current(...(args.current as Parameters<F>));\n        }, remaining);\n      }\n\n      return result.current as ReturnType<F>;\n    };\n    throttled.cancel = () => window.clearTimeout(timeout.current);\n\n    return throttled;\n  }, [wait]);\n}\n"],"names":["useEffect","useMemo","useRef","useIsomorphicLayoutEffect","useThrottledFunction","func","wait","args","result","timeout","funcRef","lastCalledTime","current","window","clearTimeout","throttled","nextArgs","now","Date","remaining","setTimeout","undefined","cancel"],"mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAQ,QAAQ;AAEnD,SAASC,yBAAyB,QAAQ,iCAAiC;AAS3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EC,GACD,OAAO,SAASC,qBACdC,IAAO,EACPC,IAAY;IAEZ,MAAMC,OAAOL;IACb,MAAMM,SAASN;IACf,MAAMO,UAAUP;IAChB,MAAMQ,UAAUR,OAAOG;IACvB,MAAMM,iBAAiBT,OAAO;IAE9BC,0BAA0B;QACxBO,QAAQE,OAAO,GAAGP;IACpB;IAEAL,UAAU;QACR,OAAO;YACLa,OAAOC,YAAY,CAACL,QAAQG,OAAO;QACrC;IACF,GAAG,EAAE;IAEL,OAAOX,QAAQ;QACb,MAAMc,YAAkC,CAAC,GAAGC;YAC1CT,KAAKK,OAAO,GAAGI;YAEf,MAAMC,MAAMC,KAAKD,GAAG;YACpB,MAAME,YAAYb,OAAQW,CAAAA,MAAMN,eAAeC,OAAO,AAAD;YACrD,IAAIO,aAAa,KAAKA,YAAYb,MAAM;gBACtCK,eAAeC,OAAO,GAAGK;gBACzBT,OAAOI,OAAO,GAAGF,QAAQE,OAAO,IAAIL,KAAKK,OAAO;YAClD,OAAO,IAAI,CAACH,QAAQG,OAAO,EAAE;gBAC3BH,QAAQG,OAAO,GAAGC,OAAOO,UAAU,CAAC;oBAClCT,eAAeC,OAAO,GAAGM,KAAKD,GAAG;oBACjCR,QAAQG,OAAO,GAAGS;oBAClB,4BAA4B;oBAC5Bb,OAAOI,OAAO,GAAGF,QAAQE,OAAO,IAAKL,KAAKK,OAAO;gBACnD,GAAGO;YACL;YAEA,OAAOX,OAAOI,OAAO;QACvB;QACAG,UAAUO,MAAM,GAAG,IAAMT,OAAOC,YAAY,CAACL,QAAQG,OAAO;QAE5D,OAAOG;IACT,GAAG;QAACT;KAAK;AACX"}
+{"version":3,"sources":["../src/useThrottledFunction.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { type AnyFunction, type CancelableFunction } from \"./types.js\";\nimport { useIsomorphicLayoutEffect } from \"./useIsomorphicLayoutEffect.js\";\n\n/**\n * @since 6.0.0\n */\nexport type ThrottledFunction<F extends AnyFunction> = CancelableFunction<\n  (...args: Parameters<F>) => ReturnType<F>\n>;\n\n/**\n * Creates a function that will only be called once every X milliseconds.\n *\n * @example Throttling Search API Requests\n * ```tsx\n * import { TextField, useThrottledFunction, useUnmounted } from \"@react-md/core\";\n * import { useState } from \"react\";\n * import type { ReactElement } from \"react\";\n *\n * interface State {\n *   error?: unknown\n *   loading: boolean;\n *   results?: {\n *     // pretend some search results\n *     id: string;\n *     name: string;\n *   }[];\n * }\n *\n * function Example(): ReactElement {\n *   const [state, setState] = useState<State>({\n *     loading: false,\n *   });\n *   // this is only required for async actions\n *   const unmounted = useUnmounted();\n *\n *   // A new search request will be fired once every 500ms as the user types.\n *   // can't use the event here since React uses synthetic events\n *   const search = useThrottledFunction(async (q: string) => {\n *     setState({\n *       loading: true,\n *       error: undefined,\n *       results: undefined,\n *     });\n *\n *     try {\n *       const response = await fetch('/search', {\n *         method: 'POST',\n *         headers: {\n *           'Content-Type': 'application/json',\n *         },\n *         body: JSON.stringify({ q }),\n *       });\n *       const json = await response.json();\n *\n *       if (!unmounted.current) {\n *         setState({\n *           loading: false,\n *           results: json,\n *         });\n *       }\n *     } catch (error) {\n *       if (!unmounted.current) {\n *         setState({\n *           error,\n *           loading: false,\n *         });\n *       }\n *     }\n *   }, 500);\n *\n *   return (\n *     <TextField\n *       type=\"search\"\n *       label=\"Search\"\n *       onChange={(event) => search(event.currentTarget.value)}\n *     />\n *   );\n * }\n * ```\n *\n * @see `useDebouncedFunction` for debounce behavior instead. (Call a\n * function only if it has not been called again for X milliseconds).\n * @since 6.0.0\n */\nexport function useThrottledFunction<F extends AnyFunction>(\n  func: F,\n  wait: number\n): ThrottledFunction<F> {\n  const args = useRef<Parameters<F>>();\n  const result = useRef<ReturnType<F>>();\n  const timeout = useRef<number | undefined>();\n  const funcRef = useRef(func);\n  const lastCalledTime = useRef(0);\n\n  useIsomorphicLayoutEffect(() => {\n    funcRef.current = func;\n  });\n\n  useEffect(() => {\n    return () => {\n      window.clearTimeout(timeout.current);\n    };\n  }, []);\n\n  return useMemo(() => {\n    const throttled: ThrottledFunction<F> = (...nextArgs) => {\n      args.current = nextArgs;\n\n      const now = Date.now();\n      const remaining = wait - (now - lastCalledTime.current);\n      if (remaining <= 0 || remaining > wait) {\n        lastCalledTime.current = now;\n        result.current = funcRef.current(...args.current);\n      } else if (!timeout.current) {\n        timeout.current = window.setTimeout(() => {\n          lastCalledTime.current = Date.now();\n          timeout.current = undefined;\n          // should exist by this time\n          result.current = funcRef.current(...(args.current as Parameters<F>));\n        }, remaining);\n      }\n\n      return result.current as ReturnType<F>;\n    };\n    throttled.cancel = () => window.clearTimeout(timeout.current);\n\n    return throttled;\n  }, [wait]);\n}\n"],"names":["useEffect","useMemo","useRef","useIsomorphicLayoutEffect","useThrottledFunction","func","wait","args","result","timeout","funcRef","lastCalledTime","current","window","clearTimeout","throttled","nextArgs","now","Date","remaining","setTimeout","undefined","cancel"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAQ,QAAQ;AAEnD,SAASC,yBAAyB,QAAQ,iCAAiC;AAS3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EC,GACD,OAAO,SAASC,qBACdC,IAAO,EACPC,IAAY;IAEZ,MAAMC,OAAOL;IACb,MAAMM,SAASN;IACf,MAAMO,UAAUP;IAChB,MAAMQ,UAAUR,OAAOG;IACvB,MAAMM,iBAAiBT,OAAO;IAE9BC,0BAA0B;QACxBO,QAAQE,OAAO,GAAGP;IACpB;IAEAL,UAAU;QACR,OAAO;YACLa,OAAOC,YAAY,CAACL,QAAQG,OAAO;QACrC;IACF,GAAG,EAAE;IAEL,OAAOX,QAAQ;QACb,MAAMc,YAAkC,CAAC,GAAGC;YAC1CT,KAAKK,OAAO,GAAGI;YAEf,MAAMC,MAAMC,KAAKD,GAAG;YACpB,MAAME,YAAYb,OAAQW,CAAAA,MAAMN,eAAeC,OAAO,AAAD;YACrD,IAAIO,aAAa,KAAKA,YAAYb,MAAM;gBACtCK,eAAeC,OAAO,GAAGK;gBACzBT,OAAOI,OAAO,GAAGF,QAAQE,OAAO,IAAIL,KAAKK,OAAO;YAClD,OAAO,IAAI,CAACH,QAAQG,OAAO,EAAE;gBAC3BH,QAAQG,OAAO,GAAGC,OAAOO,UAAU,CAAC;oBAClCT,eAAeC,OAAO,GAAGM,KAAKD,GAAG;oBACjCR,QAAQG,OAAO,GAAGS;oBAClB,4BAA4B;oBAC5Bb,OAAOI,OAAO,GAAGF,QAAQE,OAAO,IAAKL,KAAKK,OAAO;gBACnD,GAAGO;YACL;YAEA,OAAOX,OAAOI,OAAO;QACvB;QACAG,UAAUO,MAAM,GAAG,IAAMT,OAAOC,YAAY,CAACL,QAAQG,OAAO;QAE5D,OAAOG;IACT,GAAG;QAACT;KAAK;AACX"}

package/dist/useToggle.d.ts

@@ -1,6 +1,6 @@
 import type { UseStateInitializer, UseStateSetter } from "./types.js";
 /**
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export interface ToggleHookReturnValue {
     toggled: boolean;
@@ -11,8 +11,7 @@ export interface ToggleHookReturnValue {
 }
 /**
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { Button, useToggle } from "@react-md/core";
  * import type { ReactElement } from "react";

package/dist/useToggle.js

@@ -2,8 +2,7 @@
 import { useCallback, useState } from "react";
 /**
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { Button, useToggle } from "@react-md/core";
  * import type { ReactElement } from "react";

package/dist/useToggle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useToggle.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useState } from \"react\";\nimport type { UseStateInitializer, UseStateSetter } from \"./types.js\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface ToggleHookReturnValue {\n  toggled: boolean;\n  setToggled: UseStateSetter<boolean>;\n  toggle(): void;\n  enable(): void;\n  disable(): void;\n}\n\n/**\n *\n * @example\n * Simple Example\n * ```tsx\n * import { Button, useToggle } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n *\n * function Example(): ReactElement {\n *   const { toggled, toggle } = useToggle();\n *\n *   return (\n *     <>\n *       <Button onClick=[toggle]>Toggle</Button>\n *       {`Toggled: ${toggled}`}\n *     </>\n *   );\n * }\n * ```\n *\n * @param defaultValue - `false`\n */\nexport function useToggle(\n  defaultValue: UseStateInitializer<boolean> = false\n): Readonly<ToggleHookReturnValue> {\n  const [toggled, setToggled] = useState(defaultValue);\n\n  return {\n    toggled,\n    setToggled,\n    toggle: useCallback(() => {\n      setToggled((prevToggled) => !prevToggled);\n    }, []),\n    enable: useCallback(() => {\n      setToggled(true);\n    }, []),\n    disable: useCallback(() => {\n      setToggled(false);\n    }, []),\n  };\n}\n"],"names":["useCallback","useState","useToggle","defaultValue","toggled","setToggled","toggle","prevToggled","enable","disable"],"mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,QAAQ,QAAQ,QAAQ;AAc9C;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASC,UACdC,eAA6C,KAAK;IAElD,MAAM,CAACC,SAASC,WAAW,GAAGJ,SAASE;IAEvC,OAAO;QACLC;QACAC;QACAC,QAAQN,YAAY;YAClBK,WAAW,CAACE,cAAgB,CAACA;QAC/B,GAAG,EAAE;QACLC,QAAQR,YAAY;YAClBK,WAAW;QACb,GAAG,EAAE;QACLI,SAAST,YAAY;YACnBK,WAAW;QACb,GAAG,EAAE;IACP;AACF"}
+{"version":3,"sources":["../src/useToggle.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useState } from \"react\";\nimport type { UseStateInitializer, UseStateSetter } from \"./types.js\";\n\n/**\n * @since 6.0.0\n */\nexport interface ToggleHookReturnValue {\n  toggled: boolean;\n  setToggled: UseStateSetter<boolean>;\n  toggle(): void;\n  enable(): void;\n  disable(): void;\n}\n\n/**\n *\n * @example Simple Example\n * ```tsx\n * import { Button, useToggle } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n *\n * function Example(): ReactElement {\n *   const { toggled, toggle } = useToggle();\n *\n *   return (\n *     <>\n *       <Button onClick=[toggle]>Toggle</Button>\n *       {`Toggled: ${toggled}`}\n *     </>\n *   );\n * }\n * ```\n *\n * @param defaultValue - `false`\n */\nexport function useToggle(\n  defaultValue: UseStateInitializer<boolean> = false\n): Readonly<ToggleHookReturnValue> {\n  const [toggled, setToggled] = useState(defaultValue);\n\n  return {\n    toggled,\n    setToggled,\n    toggle: useCallback(() => {\n      setToggled((prevToggled) => !prevToggled);\n    }, []),\n    enable: useCallback(() => {\n      setToggled(true);\n    }, []),\n    disable: useCallback(() => {\n      setToggled(false);\n    }, []),\n  };\n}\n"],"names":["useCallback","useState","useToggle","defaultValue","toggled","setToggled","toggle","prevToggled","enable","disable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,QAAQ,QAAQ,QAAQ;AAc9C;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASC,UACdC,eAA6C,KAAK;IAElD,MAAM,CAACC,SAASC,WAAW,GAAGJ,SAASE;IAEvC,OAAO;QACLC;QACAC;QACAC,QAAQN,YAAY;YAClBK,WAAW,CAACE,cAAgB,CAACA;QAC/B,GAAG,EAAE;QACLC,QAAQR,YAAY;YAClBK,WAAW;QACb,GAAG,EAAE;QACLI,SAAST,YAAY;YACnBK,WAAW;QACb,GAAG,EAAE;IACP;AACF"}

package/dist/useUnmounted.d.ts

@@ -1,7 +1,6 @@
 import type { NonNullRef } from "./types.js";
 /**
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useUnmounted } from "@react-md/core";
  * import { useEffect, useState } from "react";
@@ -26,6 +25,6 @@ import type { NonNullRef } from "./types.js";
  *   return null;
  * }
  * ```
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export declare function useUnmounted(): NonNullRef<boolean>;

package/dist/useUnmounted.js

@@ -1,8 +1,7 @@
 "use client";
 import { useEffect, useRef } from "react";
 /**
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useUnmounted } from "@react-md/core";
  * import { useEffect, useState } from "react";
@@ -27,7 +26,7 @@ import { useEffect, useRef } from "react";
  *   return null;
  * }
  * ```
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */ export function useUnmounted() {
     const unmounted = useRef(false);
     useEffect(()=>{

package/dist/useUnmounted.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useUnmounted.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useRef } from \"react\";\nimport type { NonNullRef } from \"./types.js\";\n\n/**\n * @example\n * Simple Example\n * ```tsx\n * import { useUnmounted } from \"@react-md/core\";\n * import { useEffect, useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const [state, setState] = useState({ loading: false });\n *   const unmounted = useUnmounted();\n *\n *   useEffect(() => {\n *     async function load(): void {\n *       const result = await fetch('/some-api');\n *       const json = await response.json();\n *       if (!unmounted.current) {\n *         setState({ loading: false, result: json });\n *       }\n *     }\n *\n *     setState({ loading: true });\n *     load();\n *   }, [unmounted]);\n *\n *   return null;\n * }\n * ```\n * @remarks \\@since 6.0.0\n */\nexport function useUnmounted(): NonNullRef<boolean> {\n  const unmounted = useRef(false);\n  useEffect(() => {\n    unmounted.current = false;\n    return () => {\n      unmounted.current = true;\n    };\n  }, []);\n\n  return unmounted;\n}\n"],"names":["useEffect","useRef","useUnmounted","unmounted","current"],"mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,MAAM,QAAQ,QAAQ;AAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,SAASC;IACd,MAAMC,YAAYF,OAAO;IACzBD,UAAU;QACRG,UAAUC,OAAO,GAAG;QACpB,OAAO;YACLD,UAAUC,OAAO,GAAG;QACtB;IACF,GAAG,EAAE;IAEL,OAAOD;AACT"}
+{"version":3,"sources":["../src/useUnmounted.ts"],"sourcesContent":["\"use client\";\nimport { useEffect, useRef } from \"react\";\nimport type { NonNullRef } from \"./types.js\";\n\n/**\n * @example Simple Example\n * ```tsx\n * import { useUnmounted } from \"@react-md/core\";\n * import { useEffect, useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const [state, setState] = useState({ loading: false });\n *   const unmounted = useUnmounted();\n *\n *   useEffect(() => {\n *     async function load(): void {\n *       const result = await fetch('/some-api');\n *       const json = await response.json();\n *       if (!unmounted.current) {\n *         setState({ loading: false, result: json });\n *       }\n *     }\n *\n *     setState({ loading: true });\n *     load();\n *   }, [unmounted]);\n *\n *   return null;\n * }\n * ```\n * @since 6.0.0\n */\nexport function useUnmounted(): NonNullRef<boolean> {\n  const unmounted = useRef(false);\n  useEffect(() => {\n    unmounted.current = false;\n    return () => {\n      unmounted.current = true;\n    };\n  }, []);\n\n  return unmounted;\n}\n"],"names":["useEffect","useRef","useUnmounted","unmounted","current"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,SAAS,EAAEC,MAAM,QAAQ,QAAQ;AAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,SAASC;IACd,MAAMC,YAAYF,OAAO;IACzBD,UAAU;QACRG,UAAUC,OAAO,GAAG;QACpB,OAAO;YACLD,UAAUC,OAAO,GAAG;QACtB;IACF,GAAG,EAAE;IAEL,OAAOD;AACT"}

package/dist/useWindowSize.d.ts

@@ -1,7 +1,7 @@
 import { type ElementSize } from "./types.js";
 import { type ResizeListenerOptions } from "./useResizeListener.js";
 /**
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export interface WindowSizeOptions extends Omit<ResizeListenerOptions, "disabled" | "onUpdate"> {
     /**
@@ -36,8 +36,7 @@ export interface WindowSizeOptions extends Omit<ResizeListenerOptions, "disabled
 /**
  * This is just a convenience wrapper around the {@link useResizeListener}.
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useWindowSize } from "@react-md/core";
  * import type { ReactElement } from "react";
@@ -55,6 +54,6 @@ export interface WindowSizeOptions extends Omit<ResizeListenerOptions, "disabled
  * }
  * ```
  *
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */
 export declare function useWindowSize(options?: WindowSizeOptions): ElementSize;

package/dist/useWindowSize.js

@@ -5,8 +5,7 @@ import { useResizeListener } from "./useResizeListener.js";
 /**
  * This is just a convenience wrapper around the {@link useResizeListener}.
  *
- * @example
- * Simple Example
+ * @example Simple Example
  * ```tsx
  * import { useWindowSize } from "@react-md/core";
  * import type { ReactElement } from "react";
@@ -24,7 +23,7 @@ import { useResizeListener } from "./useResizeListener.js";
  * }
  * ```
  *
- * @remarks \@since 6.0.0
+ * @since 6.0.0
  */ export function useWindowSize(options = {}) {
     const { once, signal, capture, passive, throttle, ssrHeight = 0, ssrWidth = 0, disableWidth, disableHeight } = options;
     const ssr = useSsr();

package/dist/useWindowSize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useWindowSize.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useState } from \"react\";\nimport { useSsr } from \"./SsrProvider.js\";\nimport { type ElementSize } from \"./types.js\";\nimport {\n  useResizeListener,\n  type ResizeListenerOptions,\n} from \"./useResizeListener.js\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface WindowSizeOptions\n  extends Omit<ResizeListenerOptions, \"disabled\" | \"onUpdate\"> {\n  /**\n   * The default value to use in SSR environments for the window's height.\n   *\n   * @defaultValue `0`\n   */\n  ssrHeight?: number;\n\n  /**\n   * The default value to use in SSR environments for the window's width.\n   *\n   * @defaultValue `0`\n   */\n  ssrWidth?: number;\n\n  /**\n   * Set this to `true` to ignore resize events that only updated the height.\n   * The hook can be disabled by setting this and {@link disableWidth} to\n   * `true`.\n   *\n   * @defaultValue `false`\n   */\n  disableHeight?: boolean;\n\n  /**\n   * Set this to `true` to ignore resize events that only updated the width.\n   * The hook can be disabled by setting this and {@link disableHeight} to\n   * `true`.\n   *\n   * @defaultValue `false`\n   */\n  disableWidth?: boolean;\n}\n\n/**\n * This is just a convenience wrapper around the {@link useResizeListener}.\n *\n * @example\n * Simple Example\n * ```tsx\n * import { useWindowSize } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n * import { useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const { height, width } = useWindowSize();\n *\n *   return (\n *     <>\n *       The current window size:\n *       <pre><code>{JSON.stringify(size, null, 2)}</code></pre>\n *     </>\n *   );\n * }\n * ```\n *\n * @remarks \\@since 6.0.0\n */\nexport function useWindowSize(options: WindowSizeOptions = {}): ElementSize {\n  const {\n    once,\n    signal,\n    capture,\n    passive,\n    throttle,\n    ssrHeight = 0,\n    ssrWidth = 0,\n    disableWidth,\n    disableHeight,\n  } = options;\n\n  const ssr = useSsr();\n  const [size, setSize] = useState(() => {\n    if (typeof window === \"undefined\" || ssr) {\n      return {\n        height: ssrHeight,\n        width: ssrWidth,\n      };\n    }\n\n    return {\n      height: window.innerHeight,\n      width: window.innerWidth,\n    };\n  });\n\n  useResizeListener({\n    once,\n    signal,\n    capture,\n    passive,\n    throttle,\n    disabled: disableHeight && disableWidth,\n    onUpdate: useCallback(() => {\n      setSize((prevSize) => {\n        const nextSize: ElementSize = {\n          height: window.innerHeight,\n          width: window.innerWidth,\n        };\n\n        const isHeightChange =\n          !disableHeight && prevSize.height !== nextSize.height;\n        const isWidthChange =\n          !disableWidth && prevSize.width !== nextSize.width;\n\n        return isHeightChange || isWidthChange ? nextSize : prevSize;\n      });\n    }, [disableHeight, disableWidth]),\n  });\n\n  return size;\n}\n"],"names":["useCallback","useState","useSsr","useResizeListener","useWindowSize","options","once","signal","capture","passive","throttle","ssrHeight","ssrWidth","disableWidth","disableHeight","ssr","size","setSize","window","height","width","innerHeight","innerWidth","disabled","onUpdate","prevSize","nextSize","isHeightChange","isWidthChange"],"mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,QAAQ,QAAQ,QAAQ;AAC9C,SAASC,MAAM,QAAQ,mBAAmB;AAE1C,SACEC,iBAAiB,QAEZ,yBAAyB;AAwChC;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,cAAcC,UAA6B,CAAC,CAAC;IAC3D,MAAM,EACJC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,YAAY,CAAC,EACbC,WAAW,CAAC,EACZC,YAAY,EACZC,aAAa,EACd,GAAGT;IAEJ,MAAMU,MAAMb;IACZ,MAAM,CAACc,MAAMC,QAAQ,GAAGhB,SAAS;QAC/B,IAAI,OAAOiB,WAAW,eAAeH,KAAK;YACxC,OAAO;gBACLI,QAAQR;gBACRS,OAAOR;YACT;QACF;QAEA,OAAO;YACLO,QAAQD,OAAOG,WAAW;YAC1BD,OAAOF,OAAOI,UAAU;QAC1B;IACF;IAEAnB,kBAAkB;QAChBG;QACAC;QACAC;QACAC;QACAC;QACAa,UAAUT,iBAAiBD;QAC3BW,UAAUxB,YAAY;YACpBiB,QAAQ,CAACQ;gBACP,MAAMC,WAAwB;oBAC5BP,QAAQD,OAAOG,WAAW;oBAC1BD,OAAOF,OAAOI,UAAU;gBAC1B;gBAEA,MAAMK,iBACJ,CAACb,iBAAiBW,SAASN,MAAM,KAAKO,SAASP,MAAM;gBACvD,MAAMS,gBACJ,CAACf,gBAAgBY,SAASL,KAAK,KAAKM,SAASN,KAAK;gBAEpD,OAAOO,kBAAkBC,gBAAgBF,WAAWD;YACtD;QACF,GAAG;YAACX;YAAeD;SAAa;IAClC;IAEA,OAAOG;AACT"}
+{"version":3,"sources":["../src/useWindowSize.ts"],"sourcesContent":["\"use client\";\nimport { useCallback, useState } from \"react\";\nimport { useSsr } from \"./SsrProvider.js\";\nimport { type ElementSize } from \"./types.js\";\nimport {\n  useResizeListener,\n  type ResizeListenerOptions,\n} from \"./useResizeListener.js\";\n\n/**\n * @since 6.0.0\n */\nexport interface WindowSizeOptions\n  extends Omit<ResizeListenerOptions, \"disabled\" | \"onUpdate\"> {\n  /**\n   * The default value to use in SSR environments for the window's height.\n   *\n   * @defaultValue `0`\n   */\n  ssrHeight?: number;\n\n  /**\n   * The default value to use in SSR environments for the window's width.\n   *\n   * @defaultValue `0`\n   */\n  ssrWidth?: number;\n\n  /**\n   * Set this to `true` to ignore resize events that only updated the height.\n   * The hook can be disabled by setting this and {@link disableWidth} to\n   * `true`.\n   *\n   * @defaultValue `false`\n   */\n  disableHeight?: boolean;\n\n  /**\n   * Set this to `true` to ignore resize events that only updated the width.\n   * The hook can be disabled by setting this and {@link disableHeight} to\n   * `true`.\n   *\n   * @defaultValue `false`\n   */\n  disableWidth?: boolean;\n}\n\n/**\n * This is just a convenience wrapper around the {@link useResizeListener}.\n *\n * @example Simple Example\n * ```tsx\n * import { useWindowSize } from \"@react-md/core\";\n * import type { ReactElement } from \"react\";\n * import { useState } from \"react\";\n *\n * function Example(): ReactElement {\n *   const { height, width } = useWindowSize();\n *\n *   return (\n *     <>\n *       The current window size:\n *       <pre><code>{JSON.stringify(size, null, 2)}</code></pre>\n *     </>\n *   );\n * }\n * ```\n *\n * @since 6.0.0\n */\nexport function useWindowSize(options: WindowSizeOptions = {}): ElementSize {\n  const {\n    once,\n    signal,\n    capture,\n    passive,\n    throttle,\n    ssrHeight = 0,\n    ssrWidth = 0,\n    disableWidth,\n    disableHeight,\n  } = options;\n\n  const ssr = useSsr();\n  const [size, setSize] = useState(() => {\n    if (typeof window === \"undefined\" || ssr) {\n      return {\n        height: ssrHeight,\n        width: ssrWidth,\n      };\n    }\n\n    return {\n      height: window.innerHeight,\n      width: window.innerWidth,\n    };\n  });\n\n  useResizeListener({\n    once,\n    signal,\n    capture,\n    passive,\n    throttle,\n    disabled: disableHeight && disableWidth,\n    onUpdate: useCallback(() => {\n      setSize((prevSize) => {\n        const nextSize: ElementSize = {\n          height: window.innerHeight,\n          width: window.innerWidth,\n        };\n\n        const isHeightChange =\n          !disableHeight && prevSize.height !== nextSize.height;\n        const isWidthChange =\n          !disableWidth && prevSize.width !== nextSize.width;\n\n        return isHeightChange || isWidthChange ? nextSize : prevSize;\n      });\n    }, [disableHeight, disableWidth]),\n  });\n\n  return size;\n}\n"],"names":["useCallback","useState","useSsr","useResizeListener","useWindowSize","options","once","signal","capture","passive","throttle","ssrHeight","ssrWidth","disableWidth","disableHeight","ssr","size","setSize","window","height","width","innerHeight","innerWidth","disabled","onUpdate","prevSize","nextSize","isHeightChange","isWidthChange"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,QAAQ,QAAQ,QAAQ;AAC9C,SAASC,MAAM,QAAQ,mBAAmB;AAE1C,SACEC,iBAAiB,QAEZ,yBAAyB;AAwChC;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,SAASC,cAAcC,UAA6B,CAAC,CAAC;IAC3D,MAAM,EACJC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,YAAY,CAAC,EACbC,WAAW,CAAC,EACZC,YAAY,EACZC,aAAa,EACd,GAAGT;IAEJ,MAAMU,MAAMb;IACZ,MAAM,CAACc,MAAMC,QAAQ,GAAGhB,SAAS;QAC/B,IAAI,OAAOiB,WAAW,eAAeH,KAAK;YACxC,OAAO;gBACLI,QAAQR;gBACRS,OAAOR;YACT;QACF;QAEA,OAAO;YACLO,QAAQD,OAAOG,WAAW;YAC1BD,OAAOF,OAAOI,UAAU;QAC1B;IACF;IAEAnB,kBAAkB;QAChBG;QACAC;QACAC;QACAC;QACAC;QACAa,UAAUT,iBAAiBD;QAC3BW,UAAUxB,YAAY;YACpBiB,QAAQ,CAACQ;gBACP,MAAMC,WAAwB;oBAC5BP,QAAQD,OAAOG,WAAW;oBAC1BD,OAAOF,OAAOI,UAAU;gBAC1B;gBAEA,MAAMK,iBACJ,CAACb,iBAAiBW,SAASN,MAAM,KAAKO,SAASP,MAAM;gBACvD,MAAMS,gBACJ,CAACf,gBAAgBY,SAASL,KAAK,KAAKM,SAASN,KAAK;gBAEpD,OAAOO,kBAAkBC,gBAAgBF,WAAWD;YACtD;QACF,GAAG;YAACX;YAAeD;SAAa;IAClC;IAEA,OAAOG;AACT"}