@vibedeckx/win32-x64 0.1.16 → 0.1.19

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

@@ -1,39 +0,0 @@
-import { timeoutManager } from './timeoutManager'
-import { isServer, isValidTimeout } from './utils'
-import type { ManagedTimerId } from './timeoutManager'
-
-export abstract class Removable {
-  gcTime!: number
-  #gcTimeout?: ManagedTimerId
-
-  destroy(): void {
-    this.clearGcTimeout()
-  }
-
-  protected scheduleGc(): void {
-    this.clearGcTimeout()
-
-    if (isValidTimeout(this.gcTime)) {
-      this.#gcTimeout = timeoutManager.setTimeout(() => {
-        this.optionalRemove()
-      }, this.gcTime)
-    }
-  }
-
-  protected updateGcTime(newGcTime: number | undefined): void {
-    // Default to 5 minutes (Infinity for server-side) if no gcTime is set
-    this.gcTime = Math.max(
-      this.gcTime || 0,
-      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1000),
-    )
-  }
-
-  protected clearGcTimeout() {
-    if (this.#gcTimeout) {
-      timeoutManager.clearTimeout(this.#gcTimeout)
-      this.#gcTimeout = undefined
-    }
-  }
-
-  protected abstract optionalRemove(): void
-}

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

@@ -1,228 +0,0 @@
-import { focusManager } from './focusManager'
-import { onlineManager } from './onlineManager'
-import { pendingThenable } from './thenable'
-import { isServer, sleep } from './utils'
-import type { Thenable } from './thenable'
-import type { CancelOptions, DefaultError, NetworkMode } from './types'
-
-// TYPES
-
-interface RetryerConfig<TData = unknown, TError = DefaultError> {
-  fn: () => TData | Promise<TData>
-  initialPromise?: Promise<TData>
-  onCancel?: (error: TError) => void
-  onFail?: (failureCount: number, error: TError) => void
-  onPause?: () => void
-  onContinue?: () => void
-  retry?: RetryValue<TError>
-  retryDelay?: RetryDelayValue<TError>
-  networkMode: NetworkMode | undefined
-  canRun: () => boolean
-}
-
-export interface Retryer<TData = unknown> {
-  promise: Promise<TData>
-  cancel: (cancelOptions?: CancelOptions) => void
-  continue: () => Promise<unknown>
-  cancelRetry: () => void
-  continueRetry: () => void
-  canStart: () => boolean
-  start: () => Promise<TData>
-  status: () => 'pending' | 'resolved' | 'rejected'
-}
-
-export type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>
-
-type ShouldRetryFunction<TError = DefaultError> = (
-  failureCount: number,
-  error: TError,
-) => boolean
-
-export type RetryDelayValue<TError> = number | RetryDelayFunction<TError>
-
-type RetryDelayFunction<TError = DefaultError> = (
-  failureCount: number,
-  error: TError,
-) => number
-
-function defaultRetryDelay(failureCount: number) {
-  return Math.min(1000 * 2 ** failureCount, 30000)
-}
-
-export function canFetch(networkMode: NetworkMode | undefined): boolean {
-  return (networkMode ?? 'online') === 'online'
-    ? onlineManager.isOnline()
-    : true
-}
-
-export class CancelledError extends Error {
-  revert?: boolean
-  silent?: boolean
-  constructor(options?: CancelOptions) {
-    super('CancelledError')
-    this.revert = options?.revert
-    this.silent = options?.silent
-  }
-}
-
-/**
- * @deprecated Use instanceof `CancelledError` instead.
- */
-export function isCancelledError(value: any): value is CancelledError {
-  return value instanceof CancelledError
-}
-
-export function createRetryer<TData = unknown, TError = DefaultError>(
-  config: RetryerConfig<TData, TError>,
-): Retryer<TData> {
-  let isRetryCancelled = false
-  let failureCount = 0
-  let continueFn: ((value?: unknown) => void) | undefined
-
-  const thenable = pendingThenable<TData>()
-
-  const isResolved = () =>
-    (thenable.status as Thenable<TData>['status']) !== 'pending'
-
-  const cancel = (cancelOptions?: CancelOptions): void => {
-    if (!isResolved()) {
-      const error = new CancelledError(cancelOptions) as TError
-      reject(error)
-
-      config.onCancel?.(error)
-    }
-  }
-  const cancelRetry = () => {
-    isRetryCancelled = true
-  }
-
-  const continueRetry = () => {
-    isRetryCancelled = false
-  }
-
-  const canContinue = () =>
-    focusManager.isFocused() &&
-    (config.networkMode === 'always' || onlineManager.isOnline()) &&
-    config.canRun()
-
-  const canStart = () => canFetch(config.networkMode) && config.canRun()
-
-  const resolve = (value: any) => {
-    if (!isResolved()) {
-      continueFn?.()
-      thenable.resolve(value)
-    }
-  }
-
-  const reject = (value: any) => {
-    if (!isResolved()) {
-      continueFn?.()
-      thenable.reject(value)
-    }
-  }
-
-  const pause = () => {
-    return new Promise((continueResolve) => {
-      continueFn = (value) => {
-        if (isResolved() || canContinue()) {
-          continueResolve(value)
-        }
-      }
-      config.onPause?.()
-    }).then(() => {
-      continueFn = undefined
-      if (!isResolved()) {
-        config.onContinue?.()
-      }
-    })
-  }
-
-  // Create loop function
-  const run = () => {
-    // Do nothing if already resolved
-    if (isResolved()) {
-      return
-    }
-
-    let promiseOrValue: any
-
-    // we can re-use config.initialPromise on the first call of run()
-    const initialPromise =
-      failureCount === 0 ? config.initialPromise : undefined
-
-    // Execute query
-    try {
-      promiseOrValue = initialPromise ?? config.fn()
-    } catch (error) {
-      promiseOrValue = Promise.reject(error)
-    }
-
-    Promise.resolve(promiseOrValue)
-      .then(resolve)
-      .catch((error) => {
-        // Stop if the fetch is already resolved
-        if (isResolved()) {
-          return
-        }
-
-        // Do we need to retry the request?
-        const retry = config.retry ?? (isServer ? 0 : 3)
-        const retryDelay = config.retryDelay ?? defaultRetryDelay
-        const delay =
-          typeof retryDelay === 'function'
-            ? retryDelay(failureCount, error)
-            : retryDelay
-        const shouldRetry =
-          retry === true ||
-          (typeof retry === 'number' && failureCount < retry) ||
-          (typeof retry === 'function' && retry(failureCount, error))
-
-        if (isRetryCancelled || !shouldRetry) {
-          // We are done if the query does not need to be retried
-          reject(error)
-          return
-        }
-
-        failureCount++
-
-        // Notify on fail
-        config.onFail?.(failureCount, error)
-
-        // Delay
-        sleep(delay)
-          // Pause if the document is not visible or when the device is offline
-          .then(() => {
-            return canContinue() ? undefined : pause()
-          })
-          .then(() => {
-            if (isRetryCancelled) {
-              reject(error)
-            } else {
-              run()
-            }
-          })
-      })
-  }
-
-  return {
-    promise: thenable,
-    status: () => thenable.status,
-    cancel,
-    continue: () => {
-      continueFn?.()
-      return thenable
-    },
-    cancelRetry,
-    continueRetry,
-    canStart,
-    start: () => {
-      // Start loop
-      if (canStart()) {
-        run()
-      } else {
-        pause().then(run)
-      }
-      return thenable
-    },
-  }
-}

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

@@ -1,122 +0,0 @@
-import { addConsumeAwareSignal, addToEnd } from './utils'
-import type {
-  OmitKeyof,
-  QueryFunction,
-  QueryFunctionContext,
-  QueryKey,
-} from './types'
-
-type BaseStreamedQueryParams<TQueryFnData, TQueryKey extends QueryKey> = {
-  streamFn: (
-    context: QueryFunctionContext<TQueryKey>,
-  ) => AsyncIterable<TQueryFnData> | Promise<AsyncIterable<TQueryFnData>>
-  refetchMode?: 'append' | 'reset' | 'replace'
-}
-
-type SimpleStreamedQueryParams<
-  TQueryFnData,
-  TQueryKey extends QueryKey,
-> = BaseStreamedQueryParams<TQueryFnData, TQueryKey> & {
-  reducer?: never
-  initialValue?: never
-}
-
-type ReducibleStreamedQueryParams<
-  TQueryFnData,
-  TData,
-  TQueryKey extends QueryKey,
-> = BaseStreamedQueryParams<TQueryFnData, TQueryKey> & {
-  reducer: (acc: TData, chunk: TQueryFnData) => TData
-  initialValue: TData
-}
-
-type StreamedQueryParams<TQueryFnData, TData, TQueryKey extends QueryKey> =
-  | SimpleStreamedQueryParams<TQueryFnData, TQueryKey>
-  | ReducibleStreamedQueryParams<TQueryFnData, TData, TQueryKey>
-
-/**
- * This is a helper function to create a query function that streams data from an AsyncIterable.
- * Data will be an Array of all the chunks received.
- * The query will be in a 'pending' state until the first chunk of data is received, but will go to 'success' after that.
- * The query will stay in fetchStatus 'fetching' until the stream ends.
- * @param queryFn - The function that returns an AsyncIterable to stream data from.
- * @param refetchMode - Defines how re-fetches are handled.
- * Defaults to `'reset'`, erases all data and puts the query back into `pending` state.
- * Set to `'append'` to append new data to the existing data.
- * Set to `'replace'` to write all data to the cache once the stream ends.
- * @param reducer - A function to reduce the streamed chunks into the final data.
- * Defaults to a function that appends chunks to the end of the array.
- * @param initialValue - Initial value to be used while the first chunk is being fetched, and returned if the stream yields no values.
- */
-export function streamedQuery<
-  TQueryFnData = unknown,
-  TData = Array<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
->({
-  streamFn,
-  refetchMode = 'reset',
-  reducer = (items, chunk) =>
-    addToEnd(items as Array<TQueryFnData>, chunk) as TData,
-  initialValue = [] as TData,
-}: StreamedQueryParams<TQueryFnData, TData, TQueryKey>): QueryFunction<
-  TData,
-  TQueryKey
-> {
-  return async (context) => {
-    const query = context.client
-      .getQueryCache()
-      .find({ queryKey: context.queryKey, exact: true })
-    const isRefetch = !!query && query.state.data !== undefined
-    if (isRefetch && refetchMode === 'reset') {
-      query.setState({
-        status: 'pending',
-        data: undefined,
-        error: null,
-        fetchStatus: 'fetching',
-      })
-    }
-
-    let result = initialValue
-
-    let cancelled: boolean = false as boolean
-    const streamFnContext = addConsumeAwareSignal<
-      OmitKeyof<typeof context, 'signal'>
-    >(
-      {
-        client: context.client,
-        meta: context.meta,
-        queryKey: context.queryKey,
-        pageParam: context.pageParam,
-        direction: context.direction,
-      },
-      () => context.signal,
-      () => (cancelled = true),
-    )
-
-    const stream = await streamFn(streamFnContext)
-
-    const isReplaceRefetch = isRefetch && refetchMode === 'replace'
-
-    for await (const chunk of stream) {
-      if (cancelled) {
-        break
-      }
-
-      if (isReplaceRefetch) {
-        // don't append to the cache directly when replace-refetching
-        result = reducer(result, chunk)
-      } else {
-        context.client.setQueryData<TData>(context.queryKey, (prev) =>
-          reducer(prev === undefined ? initialValue : prev, chunk),
-        )
-      }
-    }
-
-    // finalize result: replace-refetching needs to write to the cache
-    if (isReplaceRefetch && !cancelled) {
-      context.client.setQueryData<TData>(context.queryKey, result)
-    }
-
-    return context.client.getQueryData(context.queryKey) ?? initialValue
-  }
-}

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

@@ -1,30 +0,0 @@
-export class Subscribable<TListener extends Function> {
-  protected listeners = new Set<TListener>()
-
-  constructor() {
-    this.subscribe = this.subscribe.bind(this)
-  }
-
-  subscribe(listener: TListener): () => void {
-    this.listeners.add(listener)
-
-    this.onSubscribe()
-
-    return () => {
-      this.listeners.delete(listener)
-      this.onUnsubscribe()
-    }
-  }
-
-  hasListeners(): boolean {
-    return this.listeners.size > 0
-  }
-
-  protected onSubscribe(): void {
-    // Do nothing
-  }
-
-  protected onUnsubscribe(): void {
-    // Do nothing
-  }
-}

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

@@ -1,111 +0,0 @@
-/**
- * Thenable types which matches React's types for promises
- *
- * React seemingly uses `.status`, `.value` and `.reason` properties on a promises to optimistically unwrap data from promises
- *
- * @see https://github.com/facebook/react/blob/main/packages/shared/ReactTypes.js#L112-L138
- * @see https://github.com/facebook/react/blob/4f604941569d2e8947ce1460a0b2997e835f37b9/packages/react-debug-tools/src/ReactDebugHooks.js#L224-L227
- */
-
-import { noop } from './utils'
-
-interface Fulfilled<T> {
-  status: 'fulfilled'
-  value: T
-}
-interface Rejected {
-  status: 'rejected'
-  reason: unknown
-}
-interface Pending<T> {
-  status: 'pending'
-
-  /**
-   * Resolve the promise with a value.
-   * Will remove the `resolve` and `reject` properties from the promise.
-   */
-  resolve: (value: T) => void
-  /**
-   * Reject the promise with a reason.
-   * Will remove the `resolve` and `reject` properties from the promise.
-   */
-  reject: (reason: unknown) => void
-}
-
-export type FulfilledThenable<T> = Promise<T> & Fulfilled<T>
-export type RejectedThenable<T> = Promise<T> & Rejected
-export type PendingThenable<T> = Promise<T> & Pending<T>
-
-export type Thenable<T> =
-  | FulfilledThenable<T>
-  | RejectedThenable<T>
-  | PendingThenable<T>
-
-export function pendingThenable<T>(): PendingThenable<T> {
-  let resolve: Pending<T>['resolve']
-  let reject: Pending<T>['reject']
-  // this could use `Promise.withResolvers()` in the future
-  const thenable = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  }) as PendingThenable<T>
-
-  thenable.status = 'pending'
-  thenable.catch(() => {
-    // prevent unhandled rejection errors
-  })
-
-  function finalize(data: Fulfilled<T> | Rejected) {
-    Object.assign(thenable, data)
-
-    // clear pending props props to avoid calling them twice
-    delete (thenable as Partial<PendingThenable<T>>).resolve
-    delete (thenable as Partial<PendingThenable<T>>).reject
-  }
-
-  thenable.resolve = (value) => {
-    finalize({
-      status: 'fulfilled',
-      value,
-    })
-
-    resolve(value)
-  }
-  thenable.reject = (reason) => {
-    finalize({
-      status: 'rejected',
-      reason,
-    })
-
-    reject(reason)
-  }
-
-  return thenable
-}
-
-/**
- * This function takes a Promise-like input and detects whether the data
- * is synchronously available or not.
- *
- * It does not inspect .status, .value or .reason properties of the promise,
- * as those are not always available, and the .status of React's promises
- * should not be considered part of the public API.
- */
-export function tryResolveSync(promise: Promise<unknown> | Thenable<unknown>) {
-  let data: unknown
-
-  promise
-    .then((result) => {
-      data = result
-      return result
-    }, noop)
-    // .catch can be unavailable on certain kinds of thenable's
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    ?.catch(noop)
-
-  if (data !== undefined) {
-    return { data }
-  }
-
-  return undefined
-}

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

@@ -1,135 +0,0 @@
-/**
- * {@link TimeoutManager} does not support passing arguments to the callback.
- *
- * `(_: void)` is the argument type inferred by TypeScript's default typings for
- * `setTimeout(cb, number)`.
- * If we don't accept a single void argument, then
- * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.
- */
-export type TimeoutCallback = (_: void) => void
-
-/**
- * Wrapping `setTimeout` is awkward from a typing perspective because platform
- * typings may extend the return type of `setTimeout`. For example, NodeJS
- * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be
- * able to return such a type.
- */
-export type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }
-
-/**
- * Backend for timer functions.
- */
-export type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =
-  {
-    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId
-    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void
-
-    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId
-    readonly clearInterval: (intervalId: TTimerId | undefined) => void
-  }
-
-export const defaultTimeoutProvider: TimeoutProvider<
-  ReturnType<typeof setTimeout>
-> = {
-  // We need the wrapper function syntax below instead of direct references to
-  // global setTimeout etc.
-  //
-  // BAD: `setTimeout: setTimeout`
-  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
-  //
-  // If we use direct references here, then anything that wants to spy on or
-  // replace the global setTimeout (like tests) won't work since we'll already
-  // have a hard reference to the original implementation at the time when this
-  // file was imported.
-  setTimeout: (callback, delay) => setTimeout(callback, delay),
-  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
-
-  setInterval: (callback, delay) => setInterval(callback, delay),
-  clearInterval: (intervalId) => clearInterval(intervalId),
-}
-
-/**
- * Allows customization of how timeouts are created.
- *
- * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`
- * and `gcTime`. The default TimeoutManager provider uses the platform's global
- * `setTimeout` implementation, which is known to have scalability issues with
- * thousands of timeouts on the event loop.
- *
- * If you hit this limitation, consider providing a custom TimeoutProvider that
- * coalesces timeouts.
- */
-export class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
-  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
-  // type at app boot; and if we leave that type, then any new timer provider
-  // would need to support ReturnType<typeof setTimeout>, which is infeasible.
-  //
-  // We settle for type safety for the TimeoutProvider type, and accept that
-  // this class is unsafe internally to allow for extension.
-  #provider: TimeoutProvider<any> = defaultTimeoutProvider
-  #providerCalled = false
-
-  setTimeoutProvider<TTimerId extends ManagedTimerId>(
-    provider: TimeoutProvider<TTimerId>,
-  ): void {
-    if (process.env.NODE_ENV !== 'production') {
-      if (this.#providerCalled && provider !== this.#provider) {
-        // After changing providers, `clearTimeout` will not work as expected for
-        // timeouts from the previous provider.
-        //
-        // Since they may allocate the same timeout ID, clearTimeout may cancel an
-        // arbitrary different timeout, or unexpected no-op.
-        //
-        // We could protect against this by mixing the timeout ID bits
-        // deterministically with some per-provider bits.
-        //
-        // We could internally queue `setTimeout` calls to `TimeoutManager` until
-        // some API call to set the initial provider.
-        console.error(
-          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
-          { previous: this.#provider, provider },
-        )
-      }
-    }
-
-    this.#provider = provider
-    if (process.env.NODE_ENV !== 'production') {
-      this.#providerCalled = false
-    }
-  }
-
-  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {
-    if (process.env.NODE_ENV !== 'production') {
-      this.#providerCalled = true
-    }
-    return this.#provider.setTimeout(callback, delay)
-  }
-
-  clearTimeout(timeoutId: ManagedTimerId | undefined): void {
-    this.#provider.clearTimeout(timeoutId)
-  }
-
-  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {
-    if (process.env.NODE_ENV !== 'production') {
-      this.#providerCalled = true
-    }
-    return this.#provider.setInterval(callback, delay)
-  }
-
-  clearInterval(intervalId: ManagedTimerId | undefined): void {
-    this.#provider.clearInterval(intervalId)
-  }
-}
-
-export const timeoutManager = new TimeoutManager()
-
-/**
- * In many cases code wants to delay to the next event loop tick; this is not
- * mediated by {@link timeoutManager}.
- *
- * This function is provided to make auditing the `tanstack/query-core` for
- * incorrect use of system `setTimeout` easier.
- */
-export function systemSetTimeoutZero(callback: TimeoutCallback): void {
-  setTimeout(callback, 0)
-}