Removed jsdoc types (#1181)

* removed jsdoc types from typescript files in favor of typescript types

* format

Author: overthemike

src/react.ts

@@ -20,10 +20,6 @@ import type { Snapshot } from './vanilla.ts'
  *
  * This internal hook collects the paths that were accessed during render
  * and displays them in React DevTools to help with debugging render optimizations.
- *
- * @param {object} state - The state object being tracked
- * @param {WeakMap<object, unknown>} affected - WeakMap of accessed properties
- * @private
  */
 const useAffectedDebugValue = (
   state: object,

src/react/utils/useProxy.ts

@@ -12,6 +12,7 @@ const DUMMY_SYMBOL = Symbol()
  * For the best ergonomics, you can export a custom hook from your store, so you
  * don't have to figure out a separate name for the hook reference. E.g.:
  *
+ * @example
  * export const store = proxy(initialState)
  * export const useStore = () => useProxy(store)
  * // in the component file:
@@ -20,9 +21,6 @@ const DUMMY_SYMBOL = Symbol()
  *   return <button onClick={() => {store.count++}}>{store.count}</button>
  * }
  *
- * @param proxy
- * @param options
- * @returns A new proxy which you can use in the render as well as in callbacks.
  */
 export function useProxy<T extends object>(
   proxy: T,

src/vanilla.ts

@@ -43,8 +43,6 @@ type SnapshotIgnore =
 
 /**
  * Snapshot type that converts objects to readonly versions recursively
- *
- * @template T - Type to convert to a snapshot
  */
 export type Snapshot<T> = T extends { $$valtioSnapshot: infer S }
   ? S
@@ -176,11 +174,6 @@ let createHandler: typeof createHandlerDefault = createHandlerDefault
 
 /**
  * Creates a reactive proxy object that can be tracked for changes
- *
- * @template T - Type of the object to be proxied
- * @param {T} baseObject - The object to create a proxy for
- * @returns {T} A proxied version of the input object
- * @throws {Error} If the input is not an object
  */
 export function proxy<T extends object>(baseObject: T = {} as T): T {
   if (!isObject(baseObject)) {
@@ -294,9 +287,6 @@ export function proxy<T extends object>(baseObject: T = {} as T): T {
 
 /**
  * Gets the current version number of a proxy object
- *
- * @param {unknown} proxyObject - The proxy object to get the version of
- * @returns {number | undefined} The current version number, or undefined if not a proxy
  */
 export function getVersion(proxyObject: unknown): number | undefined {
   const proxyState = proxyStateMap.get(proxyObject as object)
@@ -305,12 +295,6 @@ export function getVersion(proxyObject: unknown): number | undefined {
 
 /**
  * Subscribes to changes in a proxy object
- *
- * @template T - Type of the proxy object
- * @param {T} proxyObject - The proxy object to subscribe to
- * @param {Function} callback - Function called when the proxy object changes
- * @param {boolean} [notifyInSync] - If true, notifications happen synchronously
- * @returns {Function} Unsubscribe function to stop listening for changes
  */
 export function subscribe<T extends object>(
   proxyObject: T,
@@ -350,10 +334,6 @@ export function subscribe<T extends object>(
 
 /**
  * Creates an immutable snapshot of the current state of a proxy object
- *
- * @template T - Type of the proxy object
- * @param {T} proxyObject - The proxy object to create a snapshot from
- * @returns {Snapshot<T>} An immutable snapshot of the current state
  */
 export function snapshot<T extends object>(proxyObject: T): Snapshot<T> {
   const proxyState = proxyStateMap.get(proxyObject as object)
@@ -369,10 +349,6 @@ export function snapshot<T extends object>(proxyObject: T): Snapshot<T> {
  *
  * Objects marked with ref will be kept as references in snapshots
  * instead of being deeply copied.
- *
- * @template T - Type of the object to mark as a reference
- * @param {T} obj - The object to mark as a reference
- * @returns {T & { $$valtioSnapshot: T }} The same object with a type marker
  */
 export function ref<T extends object>(obj: T) {
   refSet.add(obj)

src/vanilla/utils/deepClone.ts

@@ -13,11 +13,6 @@ const getDefaultRefSet = (): WeakSet<object> => {
 
 /**
  * Creates a deep clone of an object, maintaining proxy behavior for Maps and Sets
- *
- * @template T - Type of the object to clone
- * @param {T} obj - The object to clone
- * @param {Function} [getRefSet=getDefaultRefSet] - Function to get the set of reference objects
- * @returns {T} A deep clone of the input object
  */
 export function deepClone<T>(
   obj: T,

src/vanilla/utils/devtools.ts

@@ -29,13 +29,6 @@ type Options = {
  *
  * Limitation: Only plain objects/values are supported.
  *
- * @template T - Type of the proxy object
- * @param {T} proxyObject - The proxy object to connect to DevTools
- * @param {Options} [options] - Configuration options for the DevTools connection
- * @param {boolean} [options.enabled] - Explicitly enable or disable the connection
- * @param {string} [options.name=''] - Name to display in DevTools
- * @returns {Function|undefined} Unsubscribe function to disconnect from DevTools, or undefined if connection failed
- *
  * @example
  * import { devtools } from 'valtio/utils'
  * const state = proxy({ count: 0, text: 'hello' })

src/vanilla/utils/proxyMap.ts

@@ -12,9 +12,6 @@ type InternalProxyObject<K, V> = Map<K, V> & {
 
 /**
  * Determines if an object is a proxy Map created with proxyMap
- *
- * @param {object} obj - The object to check
- * @returns {boolean} True if the object is a proxy Map, false otherwise
  */
 export const isProxyMap = (obj: object): boolean => {
   return (
@@ -31,24 +28,20 @@ export const isProxyMap = (obj: object): boolean => {
  * allowing you to track changes to the Map in the same way as regular proxy objects.
  * The API is the same as the standard JavaScript Map.
  *
- * @template K - Type of the Map keys
- * @template V - Type of the Map values
- * @param {Iterable<[K, V]>} [entries] - Initial key-value pairs to populate the Map
- * @returns {Map<K, V>} A proxy Map object that tracks changes
- * @throws {TypeError} If entries is not iterable
- *
  * @example
  * import { proxyMap } from 'valtio/utils'
  * const state = proxyMap([["key", "value"]])
  *
- * // can be used inside a proxy as well
+ * This can be used inside a proxy as well
+ *
  * const state = proxy({
  *   count: 1,
  *   map: proxyMap()
  * })
  *
- * // When using an object as a key, you can wrap it with `ref` so it's not proxied
- * // this is useful if you want to preserve the key equality
+ * When using an object as a key, you can wrap it with `ref` so it's not proxied
+ * this is useful if you want to preserve the key equality
+ *
  * import { ref } from 'valtio'
  *
  * const key = ref({})

src/vanilla/utils/proxySet.ts

@@ -26,9 +26,6 @@ type InternalProxySet<T> = Set<T> & {
 
 /**
  * Determines if an object is a proxy Set created with proxySet
- *
- * @param {object} obj - The object to check
- * @returns {boolean} True if the object is a proxy Set, false otherwise
  */
 export const isProxySet = (obj: object): boolean => {
   return (
@@ -46,11 +43,6 @@ export const isProxySet = (obj: object): boolean => {
  * The API extends the standard JavaScript Set with additional set operations like
  * union, intersection, difference, etc.
  *
- * @template T - Type of the Set elements
- * @param {Iterable<T>} [initialValues] - Initial values to populate the Set
- * @returns {Set<T>} A reactive proxy Set with extended methods
- * @throws {TypeError} If initialValues is not iterable
- *
  * @example
  * import { proxySet } from 'valtio/utils'
  * const state = proxySet([1,2,3])

src/vanilla/utils/watch.ts

@@ -29,10 +29,6 @@ let currentCleanups: Set<Cleanup> | undefined
  *
  * `watch` calls inside `watch` are also automatically tracked and cleaned up
  * whenever the parent `watch` reevaluates.
- *
- * @param callback
- * @returns A cleanup function that stops the callback from reevaluating and
- * also performs cleanups registered into `watch`.
  */
 export function watch(
   callback: WatchCallback,