@vibedeckx/win32-x64 0.1.16 → 0.1.19

package/node_modules/@tanstack/query-core/src/mutationCache.ts

@@ -1,244 +0,0 @@
-import { notifyManager } from './notifyManager'
-import { Mutation } from './mutation'
-import { matchMutation, noop } from './utils'
-import { Subscribable } from './subscribable'
-import type { MutationObserver } from './mutationObserver'
-import type {
-  DefaultError,
-  MutationFunctionContext,
-  MutationOptions,
-  NotifyEvent,
-} from './types'
-import type { QueryClient } from './queryClient'
-import type { Action, MutationState } from './mutation'
-import type { MutationFilters } from './utils'
-
-// TYPES
-
-interface MutationCacheConfig {
-  onError?: (
-    error: DefaultError,
-    variables: unknown,
-    onMutateResult: unknown,
-    mutation: Mutation<unknown, unknown, unknown>,
-    context: MutationFunctionContext,
-  ) => Promise<unknown> | unknown
-  onSuccess?: (
-    data: unknown,
-    variables: unknown,
-    onMutateResult: unknown,
-    mutation: Mutation<unknown, unknown, unknown>,
-    context: MutationFunctionContext,
-  ) => Promise<unknown> | unknown
-  onMutate?: (
-    variables: unknown,
-    mutation: Mutation<unknown, unknown, unknown>,
-    context: MutationFunctionContext,
-  ) => Promise<unknown> | unknown
-  onSettled?: (
-    data: unknown | undefined,
-    error: DefaultError | null,
-    variables: unknown,
-    onMutateResult: unknown,
-    mutation: Mutation<unknown, unknown, unknown>,
-    context: MutationFunctionContext,
-  ) => Promise<unknown> | unknown
-}
-
-interface NotifyEventMutationAdded extends NotifyEvent {
-  type: 'added'
-  mutation: Mutation<any, any, any, any>
-}
-interface NotifyEventMutationRemoved extends NotifyEvent {
-  type: 'removed'
-  mutation: Mutation<any, any, any, any>
-}
-
-interface NotifyEventMutationObserverAdded extends NotifyEvent {
-  type: 'observerAdded'
-  mutation: Mutation<any, any, any, any>
-  observer: MutationObserver<any, any, any>
-}
-
-interface NotifyEventMutationObserverRemoved extends NotifyEvent {
-  type: 'observerRemoved'
-  mutation: Mutation<any, any, any, any>
-  observer: MutationObserver<any, any, any>
-}
-
-interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
-  type: 'observerOptionsUpdated'
-  mutation?: Mutation<any, any, any, any>
-  observer: MutationObserver<any, any, any, any>
-}
-
-interface NotifyEventMutationUpdated extends NotifyEvent {
-  type: 'updated'
-  mutation: Mutation<any, any, any, any>
-  action: Action<any, any, any, any>
-}
-
-export type MutationCacheNotifyEvent =
-  | NotifyEventMutationAdded
-  | NotifyEventMutationRemoved
-  | NotifyEventMutationObserverAdded
-  | NotifyEventMutationObserverRemoved
-  | NotifyEventMutationObserverOptionsUpdated
-  | NotifyEventMutationUpdated
-
-type MutationCacheListener = (event: MutationCacheNotifyEvent) => void
-
-// CLASS
-
-export class MutationCache extends Subscribable<MutationCacheListener> {
-  #mutations: Set<Mutation<any, any, any, any>>
-  #scopes: Map<string, Array<Mutation<any, any, any, any>>>
-  #mutationId: number
-
-  constructor(public config: MutationCacheConfig = {}) {
-    super()
-    this.#mutations = new Set()
-    this.#scopes = new Map()
-    this.#mutationId = 0
-  }
-
-  build<TData, TError, TVariables, TOnMutateResult>(
-    client: QueryClient,
-    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,
-    state?: MutationState<TData, TError, TVariables, TOnMutateResult>,
-  ): Mutation<TData, TError, TVariables, TOnMutateResult> {
-    const mutation = new Mutation({
-      client,
-      mutationCache: this,
-      mutationId: ++this.#mutationId,
-      options: client.defaultMutationOptions(options),
-      state,
-    })
-
-    this.add(mutation)
-
-    return mutation
-  }
-
-  add(mutation: Mutation<any, any, any, any>): void {
-    this.#mutations.add(mutation)
-    const scope = scopeFor(mutation)
-    if (typeof scope === 'string') {
-      const scopedMutations = this.#scopes.get(scope)
-      if (scopedMutations) {
-        scopedMutations.push(mutation)
-      } else {
-        this.#scopes.set(scope, [mutation])
-      }
-    }
-    this.notify({ type: 'added', mutation })
-  }
-
-  remove(mutation: Mutation<any, any, any, any>): void {
-    if (this.#mutations.delete(mutation)) {
-      const scope = scopeFor(mutation)
-      if (typeof scope === 'string') {
-        const scopedMutations = this.#scopes.get(scope)
-        if (scopedMutations) {
-          if (scopedMutations.length > 1) {
-            const index = scopedMutations.indexOf(mutation)
-            if (index !== -1) {
-              scopedMutations.splice(index, 1)
-            }
-          } else if (scopedMutations[0] === mutation) {
-            this.#scopes.delete(scope)
-          }
-        }
-      }
-    }
-
-    // Currently we notify the removal even if the mutation was already removed.
-    // Consider making this an error or not notifying of the removal depending on the desired semantics.
-    this.notify({ type: 'removed', mutation })
-  }
-
-  canRun(mutation: Mutation<any, any, any, any>): boolean {
-    const scope = scopeFor(mutation)
-    if (typeof scope === 'string') {
-      const mutationsWithSameScope = this.#scopes.get(scope)
-      const firstPendingMutation = mutationsWithSameScope?.find(
-        (m) => m.state.status === 'pending',
-      )
-      // we can run if there is no current pending mutation (start use-case)
-      // or if WE are the first pending mutation (continue use-case)
-      return !firstPendingMutation || firstPendingMutation === mutation
-    } else {
-      // For unscoped mutations there are never any pending mutations in front of the
-      // current mutation
-      return true
-    }
-  }
-
-  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown> {
-    const scope = scopeFor(mutation)
-    if (typeof scope === 'string') {
-      const foundMutation = this.#scopes
-        .get(scope)
-        ?.find((m) => m !== mutation && m.state.isPaused)
-
-      return foundMutation?.continue() ?? Promise.resolve()
-    } else {
-      return Promise.resolve()
-    }
-  }
-
-  clear(): void {
-    notifyManager.batch(() => {
-      this.#mutations.forEach((mutation) => {
-        this.notify({ type: 'removed', mutation })
-      })
-      this.#mutations.clear()
-      this.#scopes.clear()
-    })
-  }
-
-  getAll(): Array<Mutation> {
-    return Array.from(this.#mutations)
-  }
-
-  find<
-    TData = unknown,
-    TError = DefaultError,
-    TVariables = any,
-    TOnMutateResult = unknown,
-  >(
-    filters: MutationFilters,
-  ): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined {
-    const defaultedFilters = { exact: true, ...filters }
-
-    return this.getAll().find((mutation) =>
-      matchMutation(defaultedFilters, mutation),
-    ) as Mutation<TData, TError, TVariables, TOnMutateResult> | undefined
-  }
-
-  findAll(filters: MutationFilters = {}): Array<Mutation> {
-    return this.getAll().filter((mutation) => matchMutation(filters, mutation))
-  }
-
-  notify(event: MutationCacheNotifyEvent) {
-    notifyManager.batch(() => {
-      this.listeners.forEach((listener) => {
-        listener(event)
-      })
-    })
-  }
-
-  resumePausedMutations(): Promise<unknown> {
-    const pausedMutations = this.getAll().filter((x) => x.state.isPaused)
-
-    return notifyManager.batch(() =>
-      Promise.all(
-        pausedMutations.map((mutation) => mutation.continue().catch(noop)),
-      ),
-    )
-  }
-}
-
-function scopeFor(mutation: Mutation<any, any, any, any>) {
-  return mutation.options.scope?.id
-}

package/node_modules/@tanstack/query-core/src/mutationObserver.ts

@@ -1,227 +0,0 @@
-import { getDefaultState } from './mutation'
-import { notifyManager } from './notifyManager'
-import { Subscribable } from './subscribable'
-import { hashKey, shallowEqualObjects } from './utils'
-import type { QueryClient } from './queryClient'
-import type {
-  DefaultError,
-  MutateOptions,
-  MutationFunctionContext,
-  MutationObserverOptions,
-  MutationObserverResult,
-} from './types'
-import type { Action, Mutation } from './mutation'
-
-// TYPES
-
-type MutationObserverListener<TData, TError, TVariables, TOnMutateResult> = (
-  result: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,
-) => void
-
-// CLASS
-
-export class MutationObserver<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TOnMutateResult = unknown,
-> extends Subscribable<
-  MutationObserverListener<TData, TError, TVariables, TOnMutateResult>
-> {
-  options!: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>
-
-  #client: QueryClient
-  #currentResult: MutationObserverResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > = undefined!
-  #currentMutation?: Mutation<TData, TError, TVariables, TOnMutateResult>
-  #mutateOptions?: MutateOptions<TData, TError, TVariables, TOnMutateResult>
-
-  constructor(
-    client: QueryClient,
-    options: MutationObserverOptions<
-      TData,
-      TError,
-      TVariables,
-      TOnMutateResult
-    >,
-  ) {
-    super()
-
-    this.#client = client
-    this.setOptions(options)
-    this.bindMethods()
-    this.#updateResult()
-  }
-
-  protected bindMethods(): void {
-    this.mutate = this.mutate.bind(this)
-    this.reset = this.reset.bind(this)
-  }
-
-  setOptions(
-    options: MutationObserverOptions<
-      TData,
-      TError,
-      TVariables,
-      TOnMutateResult
-    >,
-  ) {
-    const prevOptions = this.options as
-      | MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>
-      | undefined
-    this.options = this.#client.defaultMutationOptions(options)
-    if (!shallowEqualObjects(this.options, prevOptions)) {
-      this.#client.getMutationCache().notify({
-        type: 'observerOptionsUpdated',
-        mutation: this.#currentMutation,
-        observer: this,
-      })
-    }
-
-    if (
-      prevOptions?.mutationKey &&
-      this.options.mutationKey &&
-      hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)
-    ) {
-      this.reset()
-    } else if (this.#currentMutation?.state.status === 'pending') {
-      this.#currentMutation.setOptions(this.options)
-    }
-  }
-
-  protected onUnsubscribe(): void {
-    if (!this.hasListeners()) {
-      this.#currentMutation?.removeObserver(this)
-    }
-  }
-
-  onMutationUpdate(
-    action: Action<TData, TError, TVariables, TOnMutateResult>,
-  ): void {
-    this.#updateResult()
-
-    this.#notify(action)
-  }
-
-  getCurrentResult(): MutationObserverResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > {
-    return this.#currentResult
-  }
-
-  reset(): void {
-    // reset needs to remove the observer from the mutation because there is no way to "get it back"
-    // another mutate call will yield a new mutation!
-    this.#currentMutation?.removeObserver(this)
-    this.#currentMutation = undefined
-    this.#updateResult()
-    this.#notify()
-  }
-
-  mutate(
-    variables: TVariables,
-    options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>,
-  ): Promise<TData> {
-    this.#mutateOptions = options
-
-    this.#currentMutation?.removeObserver(this)
-
-    this.#currentMutation = this.#client
-      .getMutationCache()
-      .build(this.#client, this.options)
-
-    this.#currentMutation.addObserver(this)
-
-    return this.#currentMutation.execute(variables)
-  }
-
-  #updateResult(): void {
-    const state =
-      this.#currentMutation?.state ??
-      getDefaultState<TData, TError, TVariables, TOnMutateResult>()
-
-    this.#currentResult = {
-      ...state,
-      isPending: state.status === 'pending',
-      isSuccess: state.status === 'success',
-      isError: state.status === 'error',
-      isIdle: state.status === 'idle',
-      mutate: this.mutate,
-      reset: this.reset,
-    } as MutationObserverResult<TData, TError, TVariables, TOnMutateResult>
-  }
-
-  #notify(action?: Action<TData, TError, TVariables, TOnMutateResult>): void {
-    notifyManager.batch(() => {
-      // First trigger the mutate callbacks
-      if (this.#mutateOptions && this.hasListeners()) {
-        const variables = this.#currentResult.variables!
-        const onMutateResult = this.#currentResult.context
-
-        const context = {
-          client: this.#client,
-          meta: this.options.meta,
-          mutationKey: this.options.mutationKey,
-        } satisfies MutationFunctionContext
-
-        if (action?.type === 'success') {
-          try {
-            this.#mutateOptions.onSuccess?.(
-              action.data,
-              variables,
-              onMutateResult,
-              context,
-            )
-          } catch (e) {
-            void Promise.reject(e)
-          }
-          try {
-            this.#mutateOptions.onSettled?.(
-              action.data,
-              null,
-              variables,
-              onMutateResult,
-              context,
-            )
-          } catch (e) {
-            void Promise.reject(e)
-          }
-        } else if (action?.type === 'error') {
-          try {
-            this.#mutateOptions.onError?.(
-              action.error,
-              variables,
-              onMutateResult,
-              context,
-            )
-          } catch (e) {
-            void Promise.reject(e)
-          }
-          try {
-            this.#mutateOptions.onSettled?.(
-              undefined,
-              action.error,
-              variables,
-              onMutateResult,
-              context,
-            )
-          } catch (e) {
-            void Promise.reject(e)
-          }
-        }
-      }
-
-      // Then trigger the listeners
-      this.listeners.forEach((listener) => {
-        listener(this.#currentResult)
-      })
-    })
-  }
-}

package/node_modules/@tanstack/query-core/src/notifyManager.ts

@@ -1,99 +0,0 @@
-// TYPES
-
-import { systemSetTimeoutZero } from './timeoutManager'
-
-type NotifyCallback = () => void
-
-type NotifyFunction = (callback: () => void) => void
-
-type BatchNotifyFunction = (callback: () => void) => void
-
-type BatchCallsCallback<T extends Array<unknown>> = (...args: T) => void
-
-type ScheduleFunction = (callback: () => void) => void
-
-export const defaultScheduler: ScheduleFunction = systemSetTimeoutZero
-
-export function createNotifyManager() {
-  let queue: Array<NotifyCallback> = []
-  let transactions = 0
-  let notifyFn: NotifyFunction = (callback) => {
-    callback()
-  }
-  let batchNotifyFn: BatchNotifyFunction = (callback: () => void) => {
-    callback()
-  }
-  let scheduleFn = defaultScheduler
-
-  const schedule = (callback: NotifyCallback): void => {
-    if (transactions) {
-      queue.push(callback)
-    } else {
-      scheduleFn(() => {
-        notifyFn(callback)
-      })
-    }
-  }
-  const flush = (): void => {
-    const originalQueue = queue
-    queue = []
-    if (originalQueue.length) {
-      scheduleFn(() => {
-        batchNotifyFn(() => {
-          originalQueue.forEach((callback) => {
-            notifyFn(callback)
-          })
-        })
-      })
-    }
-  }
-
-  return {
-    batch: <T>(callback: () => T): T => {
-      let result
-      transactions++
-      try {
-        result = callback()
-      } finally {
-        transactions--
-        if (!transactions) {
-          flush()
-        }
-      }
-      return result
-    },
-    /**
-     * All calls to the wrapped function will be batched.
-     */
-    batchCalls: <T extends Array<unknown>>(
-      callback: BatchCallsCallback<T>,
-    ): BatchCallsCallback<T> => {
-      return (...args) => {
-        schedule(() => {
-          callback(...args)
-        })
-      }
-    },
-    schedule,
-    /**
-     * Use this method to set a custom notify function.
-     * This can be used to for example wrap notifications with `React.act` while running tests.
-     */
-    setNotifyFunction: (fn: NotifyFunction) => {
-      notifyFn = fn
-    },
-    /**
-     * Use this method to set a custom function to batch notifications together into a single tick.
-     * By default React Query will use the batch function provided by ReactDOM or React Native.
-     */
-    setBatchNotifyFunction: (fn: BatchNotifyFunction) => {
-      batchNotifyFn = fn
-    },
-    setScheduler: (fn: ScheduleFunction) => {
-      scheduleFn = fn
-    },
-  } as const
-}
-
-// SINGLETON
-export const notifyManager = createNotifyManager()

package/node_modules/@tanstack/query-core/src/onlineManager.ts

@@ -1,71 +0,0 @@
-import { Subscribable } from './subscribable'
-import { isServer } from './utils'
-
-type Listener = (online: boolean) => void
-type SetupFn = (setOnline: Listener) => (() => void) | undefined
-
-export class OnlineManager extends Subscribable<Listener> {
-  #online = true
-  #cleanup?: () => void
-
-  #setup: SetupFn
-
-  constructor() {
-    super()
-    this.#setup = (onOnline) => {
-      // addEventListener does not exist in React Native, but window does
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (!isServer && window.addEventListener) {
-        const onlineListener = () => onOnline(true)
-        const offlineListener = () => onOnline(false)
-        // Listen to online
-        window.addEventListener('online', onlineListener, false)
-        window.addEventListener('offline', offlineListener, false)
-
-        return () => {
-          // Be sure to unsubscribe if a new handler is set
-          window.removeEventListener('online', onlineListener)
-          window.removeEventListener('offline', offlineListener)
-        }
-      }
-
-      return
-    }
-  }
-
-  protected onSubscribe(): void {
-    if (!this.#cleanup) {
-      this.setEventListener(this.#setup)
-    }
-  }
-
-  protected onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.#cleanup?.()
-      this.#cleanup = undefined
-    }
-  }
-
-  setEventListener(setup: SetupFn): void {
-    this.#setup = setup
-    this.#cleanup?.()
-    this.#cleanup = setup(this.setOnline.bind(this))
-  }
-
-  setOnline(online: boolean): void {
-    const changed = this.#online !== online
-
-    if (changed) {
-      this.#online = online
-      this.listeners.forEach((listener) => {
-        listener(online)
-      })
-    }
-  }
-
-  isOnline(): boolean {
-    return this.#online
-  }
-}
-
-export const onlineManager = new OnlineManager()