Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

2.53 kB

import type { Key } from 'next/dist/compiled/path-to-regexp'
import { regexpToFunction } from 'next/dist/compiled/path-to-regexp'
import { pathToRegexp } from 'next/dist/compiled/path-to-regexp'

interface Options {
  /**
   * A transformer function that will be applied to the regexp generated
   * from the provided path and path-to-regexp.
   */
  regexModifier?: (regex: string) => string
  /**
   * When true the function will remove all unnamed parameters
   * from the matched parameters.
   */
  removeUnnamedParams?: boolean
  /**
   * When true the regexp won't allow an optional trailing delimiter
   * to match.
   */
  strict?: boolean

  /**
   * When true the matcher will be case-sensitive, defaults to false
   */
  sensitive?: boolean
}

export type PatchMatcher = (
  pathname: string,
  params?: Record<string, any>
) => Record<string, any> | false

/**
 * Generates a path matcher function for a given path and options based on
 * path-to-regexp. By default the match will be case insensitive, non strict
 * and delimited by `/`.
 */
export function getPathMatch(path: string, options?: Options): PatchMatcher {
  const keys: Key[] = []
  const regexp = pathToRegexp(path, keys, {
    delimiter: '/',
    sensitive:
      typeof options?.sensitive === 'boolean' ? options.sensitive : false,
    strict: options?.strict,
  })

  const matcher = regexpToFunction<Record<string, any>>(
    options?.regexModifier
      ? new RegExp(options.regexModifier(regexp.source), regexp.flags)
      : regexp,
    keys
  )

  /**
   * A matcher function that will check if a given pathname matches the path
   * given in the builder function. When the path does not match it will return
   * `false` but if it does it will return an object with the matched params
   * merged with the params provided in the second argument.
   */
  return (pathname, params) => {
    // If no pathname is provided it's not a match.
    if (typeof pathname !== 'string') return false

    const match = matcher(pathname)

    // If the path did not match `false` will be returned.
    if (!match) return false

    /**
     * If unnamed params are not allowed they must be removed from
     * the matched parameters. path-to-regexp uses "string" for named and
     * "number" for unnamed parameters.
     */
    if (options?.removeUnnamedParams) {
      for (const key of keys) {
        if (typeof key.name === 'number') {
          delete match.params[key.name]
        }
      }
    }

    return { ...params, ...match.params }
  }
}

	import type { Key } from 'next/dist/compiled/path-to-regexp'
	import { regexpToFunction } from 'next/dist/compiled/path-to-regexp'
	import { pathToRegexp } from 'next/dist/compiled/path-to-regexp'

	interface Options {
	/**
	* A transformer function that will be applied to the regexp generated
	* from the provided path and path-to-regexp.
	*/
	regexModifier?: (regex: string) => string
	/**
	* When true the function will remove all unnamed parameters
	* from the matched parameters.
	*/
	removeUnnamedParams?: boolean
	/**
	* When true the regexp won't allow an optional trailing delimiter
	* to match.
	*/
	strict?: boolean

	/**
	* When true the matcher will be case-sensitive, defaults to false
	*/
	sensitive?: boolean
	}

	export type PatchMatcher = (
	pathname: string,
	params?: Record<string, any>
	) => Record<string, any> \| false

	/**
	* Generates a path matcher function for a given path and options based on
	* path-to-regexp. By default the match will be case insensitive, non strict
	* and delimited by `/`.
	*/
	export function getPathMatch(path: string, options?: Options): PatchMatcher {
	const keys: Key[] = []
	const regexp = pathToRegexp(path, keys, {
	delimiter: '/',
	sensitive:
	typeof options?.sensitive === 'boolean' ? options.sensitive : false,
	strict: options?.strict,
	})

	const matcher = regexpToFunction<Record<string, any>>(
	options?.regexModifier
	? new RegExp(options.regexModifier(regexp.source), regexp.flags)
	: regexp,
	keys
	)

	/**
	* A matcher function that will check if a given pathname matches the path
	* given in the builder function. When the path does not match it will return
	* `false` but if it does it will return an object with the matched params
	* merged with the params provided in the second argument.
	*/
	return (pathname, params) => {
	// If no pathname is provided it's not a match.
	if (typeof pathname !== 'string') return false

	const match = matcher(pathname)

	// If the path did not match `false` will be returned.
	if (!match) return false

	/**
	* If unnamed params are not allowed they must be removed from
	* the matched parameters. path-to-regexp uses "string" for named and
	* "number" for unnamed parameters.
	*/
	if (options?.removeUnnamedParams) {
	for (const key of keys) {
	if (typeof key.name === 'number') {
	delete match.params[key.name]
	}
	}
	}

	return { ...params, ...match.params }
	}
	}