Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

10.2 kB

import { QueriesObserver, noop, notifyManager } from '@tanstack/query-core'
import { derived, get, readable } from 'svelte/store'
import { useIsRestoring } from './useIsRestoring.js'
import { useQueryClient } from './useQueryClient.js'
import { isSvelteStore } from './utils.js'
import type { Readable } from 'svelte/store'
import type { StoreOrVal } from './types.js'
import type {
  DefaultError,
  DefinedQueryObserverResult,
  OmitKeyof,
  QueriesObserverOptions,
  QueriesPlaceholderDataFunction,
  QueryClient,
  QueryFunction,
  QueryKey,
  QueryObserverOptions,
  QueryObserverResult,
  ThrowOnError,
} from '@tanstack/query-core'

// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
// `placeholderData` function always gets undefined passed
type QueryObserverOptionsForCreateQueries<
  TQueryFnData = unknown,
  TError = DefaultError,
  TData = TQueryFnData,
  TQueryKey extends QueryKey = QueryKey,
> = OmitKeyof<
  QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
  'placeholderData'
> & {
  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
}

// Avoid TS depth-limit error in case of large array literal
type MAXIMUM_DEPTH = 20

// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
type SkipTokenForUseQueries = symbol

type GetQueryObserverOptionsForCreateQueries<T> =
  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
  T extends {
    queryFnData: infer TQueryFnData
    error?: infer TError
    data: infer TData
  }
    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
      : T extends { data: infer TData; error?: infer TError }
        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>
        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
          T extends [infer TQueryFnData, infer TError, infer TData]
          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
          : T extends [infer TQueryFnData, infer TError]
            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
            : T extends [infer TQueryFnData]
              ? QueryObserverOptionsForCreateQueries<TQueryFnData>
              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
                T extends {
                    queryFn?:
                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
                      | SkipTokenForUseQueries
                    select?: (data: any) => infer TData
                    throwOnError?: ThrowOnError<any, infer TError, any, any>
                  }
                ? QueryObserverOptionsForCreateQueries<
                    TQueryFnData,
                    unknown extends TError ? DefaultError : TError,
                    unknown extends TData ? TQueryFnData : TData,
                    TQueryKey
                  >
                : // Fallback
                  QueryObserverOptionsForCreateQueries

// A defined initialData setting should return a DefinedQueryObserverResult rather than CreateQueryResult
type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
  initialData?: infer TInitialData
}
  ? unknown extends TInitialData
    ? QueryObserverResult<TData, TError>
    : TInitialData extends TData
      ? DefinedQueryObserverResult<TData, TError>
      : TInitialData extends () => infer TInitialDataResult
        ? unknown extends TInitialDataResult
          ? QueryObserverResult<TData, TError>
          : TInitialDataResult extends TData
            ? DefinedQueryObserverResult<TData, TError>
            : QueryObserverResult<TData, TError>
        : QueryObserverResult<TData, TError>
  : QueryObserverResult<TData, TError>

type GetCreateQueryResult<T> =
  // Part 1: responsible for mapping explicit type parameter to function result, if object
  T extends { queryFnData: any; error?: infer TError; data: infer TData }
    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
      : T extends { data: infer TData; error?: infer TError }
        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
          T extends [any, infer TError, infer TData]
          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
          : T extends [infer TQueryFnData, infer TError]
            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
            : T extends [infer TQueryFnData]
              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>
              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
                T extends {
                    queryFn?:
                      | QueryFunction<infer TQueryFnData, any>
                      | SkipTokenForUseQueries
                    select?: (data: any) => infer TData
                    throwOnError?: ThrowOnError<any, infer TError, any, any>
                  }
                ? GetDefinedOrUndefinedQueryResult<
                    T,
                    unknown extends TData ? TQueryFnData : TData,
                    unknown extends TError ? DefaultError : TError
                  >
                : // Fallback
                  QueryObserverResult

/**
 * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
 */
export type QueriesOptions<
  T extends Array<any>,
  TResults extends Array<any> = [],
  TDepth extends ReadonlyArray<number> = [],
> = TDepth['length'] extends MAXIMUM_DEPTH
  ? Array<QueryObserverOptionsForCreateQueries>
  : T extends []
    ? []
    : T extends [infer Head]
      ? [...TResults, GetQueryObserverOptionsForCreateQueries<Head>]
      : T extends [infer Head, ...infer Tails]
        ? QueriesOptions<
            [...Tails],
            [...TResults, GetQueryObserverOptionsForCreateQueries<Head>],
            [...TDepth, 1]
          >
        : ReadonlyArray<unknown> extends T
          ? T
          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
            // use this to infer the param types in the case of Array.map() argument
            T extends Array<
                QueryObserverOptionsForCreateQueries<
                  infer TQueryFnData,
                  infer TError,
                  infer TData,
                  infer TQueryKey
                >
              >
            ? Array<
                QueryObserverOptionsForCreateQueries<
                  TQueryFnData,
                  TError,
                  TData,
                  TQueryKey
                >
              >
            : // Fallback
              Array<QueryObserverOptionsForCreateQueries>

/**
 * QueriesResults reducer recursively maps type param to results
 */
export type QueriesResults<
  T extends Array<any>,
  TResults extends Array<any> = [],
  TDepth extends ReadonlyArray<number> = [],
> = TDepth['length'] extends MAXIMUM_DEPTH
  ? Array<QueryObserverResult>
  : T extends []
    ? []
    : T extends [infer Head]
      ? [...TResults, GetCreateQueryResult<Head>]
      : T extends [infer Head, ...infer Tails]
        ? QueriesResults<
            [...Tails],
            [...TResults, GetCreateQueryResult<Head>],
            [...TDepth, 1]
          >
        : { [K in keyof T]: GetCreateQueryResult<T[K]> }

export function createQueries<
  T extends Array<any>,
  TCombinedResult = QueriesResults<T>,
>(
  {
    queries,
    ...options
  }: {
    queries:
      | StoreOrVal<[...QueriesOptions<T>]>
      | StoreOrVal<
          [...{ [K in keyof T]: GetQueryObserverOptionsForCreateQueries<T[K]> }]
        >
    combine?: (result: QueriesResults<T>) => TCombinedResult
  },
  queryClient?: QueryClient,
): Readable<TCombinedResult> {
  const client = useQueryClient(queryClient)
  const isRestoring = useIsRestoring()

  const queriesStore = isSvelteStore(queries) ? queries : readable(queries)

  const defaultedQueriesStore = derived(
    [queriesStore, isRestoring],
    ([$queries, $isRestoring]) => {
      return $queries.map((opts) => {
        const defaultedOptions = client.defaultQueryOptions(
          opts as QueryObserverOptions,
        )
        // Make sure the results are already in fetching state before subscribing or updating options
        defaultedOptions._optimisticResults = $isRestoring
          ? 'isRestoring'
          : 'optimistic'
        return defaultedOptions
      })
    },
  )
  const observer = new QueriesObserver<TCombinedResult>(
    client,
    get(defaultedQueriesStore),
    options as QueriesObserverOptions<TCombinedResult>,
  )

  defaultedQueriesStore.subscribe(($defaultedQueries) => {
    // Do not notify on updates because of changes in the options because
    // these changes should already be reflected in the optimistic result.
    observer.setQueries(
      $defaultedQueries,
      options as QueriesObserverOptions<TCombinedResult>,
    )
  })

  const result = derived([isRestoring], ([$isRestoring], set) => {
    const unsubscribe = $isRestoring
      ? noop
      : observer.subscribe(notifyManager.batchCalls(set))

    return () => unsubscribe()
  })

  const { subscribe } = derived(
    [result, defaultedQueriesStore],
    // @ts-expect-error svelte-check thinks this is unused
    ([$result, $defaultedQueriesStore]) => {
      const [rawResult, combineResult, trackResult] =
        observer.getOptimisticResult(
          $defaultedQueriesStore,
          (options as QueriesObserverOptions<TCombinedResult>).combine,
        )
      $result = rawResult
      return combineResult(trackResult())
    },
  )

  return { subscribe }
}

	import { QueriesObserver, noop, notifyManager } from '@tanstack/query-core'
	import { derived, get, readable } from 'svelte/store'
	import { useIsRestoring } from './useIsRestoring.js'
	import { useQueryClient } from './useQueryClient.js'
	import { isSvelteStore } from './utils.js'
	import type { Readable } from 'svelte/store'
	import type { StoreOrVal } from './types.js'
	import type {
	DefaultError,
	DefinedQueryObserverResult,
	OmitKeyof,
	QueriesObserverOptions,
	QueriesPlaceholderDataFunction,
	QueryClient,
	QueryFunction,
	QueryKey,
	QueryObserverOptions,
	QueryObserverResult,
	ThrowOnError,
	} from '@tanstack/query-core'

	// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
	// `placeholderData` function always gets undefined passed
	type QueryObserverOptionsForCreateQueries<
	TQueryFnData = unknown,
	TError = DefaultError,
	TData = TQueryFnData,
	TQueryKey extends QueryKey = QueryKey,
	> = OmitKeyof<
	QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
	'placeholderData'
	> & {
	placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>
	}

	// Avoid TS depth-limit error in case of large array literal
	type MAXIMUM_DEPTH = 20

	// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
	type SkipTokenForUseQueries = symbol

	type GetQueryObserverOptionsForCreateQueries<T> =
	// Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
	T extends {
	queryFnData: infer TQueryFnData
	error?: infer TError
	data: infer TData
	}
	? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
	: T extends { queryFnData: infer TQueryFnData; error?: infer TError }
	? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
	: T extends { data: infer TData; error?: infer TError }
	? QueryObserverOptionsForCreateQueries<unknown, TError, TData>
	: // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
	T extends [infer TQueryFnData, infer TError, infer TData]
	? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
	: T extends [infer TQueryFnData, infer TError]
	? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
	: T extends [infer TQueryFnData]
	? QueryObserverOptionsForCreateQueries<TQueryFnData>
	: // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
	T extends {
	queryFn?:
	\| QueryFunction<infer TQueryFnData, infer TQueryKey>
	\| SkipTokenForUseQueries
	select?: (data: any) => infer TData
	throwOnError?: ThrowOnError<any, infer TError, any, any>
	}
	? QueryObserverOptionsForCreateQueries<
	TQueryFnData,
	unknown extends TError ? DefaultError : TError,
	unknown extends TData ? TQueryFnData : TData,
	TQueryKey
	>
	: // Fallback
	QueryObserverOptionsForCreateQueries

	// A defined initialData setting should return a DefinedQueryObserverResult rather than CreateQueryResult
	type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
	initialData?: infer TInitialData
	}
	? unknown extends TInitialData
	? QueryObserverResult<TData, TError>
	: TInitialData extends TData
	? DefinedQueryObserverResult<TData, TError>
	: TInitialData extends () => infer TInitialDataResult
	? unknown extends TInitialDataResult
	? QueryObserverResult<TData, TError>
	: TInitialDataResult extends TData
	? DefinedQueryObserverResult<TData, TError>
	: QueryObserverResult<TData, TError>
	: QueryObserverResult<TData, TError>
	: QueryObserverResult<TData, TError>

	type GetCreateQueryResult<T> =
	// Part 1: responsible for mapping explicit type parameter to function result, if object
	T extends { queryFnData: any; error?: infer TError; data: infer TData }
	? GetDefinedOrUndefinedQueryResult<T, TData, TError>
	: T extends { queryFnData: infer TQueryFnData; error?: infer TError }
	? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
	: T extends { data: infer TData; error?: infer TError }
	? GetDefinedOrUndefinedQueryResult<T, TData, TError>
	: // Part 2: responsible for mapping explicit type parameter to function result, if tuple
	T extends [any, infer TError, infer TData]
	? GetDefinedOrUndefinedQueryResult<T, TData, TError>
	: T extends [infer TQueryFnData, infer TError]
	? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
	: T extends [infer TQueryFnData]
	? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>
	: // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
	T extends {
	queryFn?:
	\| QueryFunction<infer TQueryFnData, any>
	\| SkipTokenForUseQueries
	select?: (data: any) => infer TData
	throwOnError?: ThrowOnError<any, infer TError, any, any>
	}
	? GetDefinedOrUndefinedQueryResult<
	T,
	unknown extends TData ? TQueryFnData : TData,
	unknown extends TError ? DefaultError : TError
	>
	: // Fallback
	QueryObserverResult

	/**
	* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
	*/
	export type QueriesOptions<
	T extends Array<any>,
	TResults extends Array<any> = [],
	TDepth extends ReadonlyArray<number> = [],
	> = TDepth['length'] extends MAXIMUM_DEPTH
	? Array<QueryObserverOptionsForCreateQueries>
	: T extends []
	? []
	: T extends [infer Head]
	? [...TResults, GetQueryObserverOptionsForCreateQueries<Head>]
	: T extends [infer Head, ...infer Tails]
	? QueriesOptions<
	[...Tails],
	[...TResults, GetQueryObserverOptionsForCreateQueries<Head>],
	[...TDepth, 1]
	>
	: ReadonlyArray<unknown> extends T
	? T
	: // If T is some array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
	// use this to infer the param types in the case of Array.map() argument
	T extends Array<
	QueryObserverOptionsForCreateQueries<
	infer TQueryFnData,
	infer TError,
	infer TData,
	infer TQueryKey
	>
	>
	? Array<
	QueryObserverOptionsForCreateQueries<
	TQueryFnData,
	TError,
	TData,
	TQueryKey
	>
	>
	: // Fallback
	Array<QueryObserverOptionsForCreateQueries>

	/**
	* QueriesResults reducer recursively maps type param to results
	*/
	export type QueriesResults<
	T extends Array<any>,
	TResults extends Array<any> = [],
	TDepth extends ReadonlyArray<number> = [],
	> = TDepth['length'] extends MAXIMUM_DEPTH
	? Array<QueryObserverResult>
	: T extends []
	? []
	: T extends [infer Head]
	? [...TResults, GetCreateQueryResult<Head>]
	: T extends [infer Head, ...infer Tails]
	? QueriesResults<
	[...Tails],
	[...TResults, GetCreateQueryResult<Head>],
	[...TDepth, 1]
	>
	: { [K in keyof T]: GetCreateQueryResult<T[K]> }

	export function createQueries<
	T extends Array<any>,
	TCombinedResult = QueriesResults<T>,
	>(
	{
	queries,
	...options
	}: {
	queries:
	\| StoreOrVal<[...QueriesOptions<T>]>
	\| StoreOrVal<
	[...{ [K in keyof T]: GetQueryObserverOptionsForCreateQueries<T[K]> }]
	>
	combine?: (result: QueriesResults<T>) => TCombinedResult
	},
	queryClient?: QueryClient,
	): Readable<TCombinedResult> {
	const client = useQueryClient(queryClient)
	const isRestoring = useIsRestoring()

	const queriesStore = isSvelteStore(queries) ? queries : readable(queries)

	const defaultedQueriesStore = derived(
	[queriesStore, isRestoring],
	([$queries, $isRestoring]) => {
	return $queries.map((opts) => {
	const defaultedOptions = client.defaultQueryOptions(
	opts as QueryObserverOptions,
	)
	// Make sure the results are already in fetching state before subscribing or updating options
	defaultedOptions._optimisticResults = $isRestoring
	? 'isRestoring'
	: 'optimistic'
	return defaultedOptions
	})
	},
	)
	const observer = new QueriesObserver<TCombinedResult>(
	client,
	get(defaultedQueriesStore),
	options as QueriesObserverOptions<TCombinedResult>,
	)

	defaultedQueriesStore.subscribe(($defaultedQueries) => {
	// Do not notify on updates because of changes in the options because
	// these changes should already be reflected in the optimistic result.
	observer.setQueries(
	$defaultedQueries,
	options as QueriesObserverOptions<TCombinedResult>,
	)
	})

	const result = derived([isRestoring], ([$isRestoring], set) => {
	const unsubscribe = $isRestoring
	? noop
	: observer.subscribe(notifyManager.batchCalls(set))

	return () => unsubscribe()
	})

	const { subscribe } = derived(
	[result, defaultedQueriesStore],
	// @ts-expect-error svelte-check thinks this is unused
	([$result, $defaultedQueriesStore]) => {
	const [rawResult, combineResult, trackResult] =
	observer.getOptimisticResult(
	$defaultedQueriesStore,
	(options as QueriesObserverOptions<TCombinedResult>).combine,
	)
	$result = rawResult
	return combineResult(trackResult())
	},
	)

	return { subscribe }
	}