proposal: useSort

[okxiaoliang4]

Clear and concise description of the problem

Composable reactive sort array.

Suggested solution

// useSort/index.ts
import { computed } from '@vue/reactivity'
import type { MaybeRef } from '@vueuse/shared'
import { unref } from 'vue-demi'

export type UseSortCompareFn<T> = (a: T, b: T) => number

export type UseSortFn<T> = (arr: T[], compareFn: UseSortCompareFn<T>) => T[]

const defaultCompare: UseSortCompareFn<number> = (a, b) => a - b

export interface UseSortOptions<T> {
  compareFn?: UseSortCompareFn<T>
}

export function useSort<T>(arr: MaybeRef<T[]>, sortFn: UseSortFn<T>, options: UseSortOptions<T> = {}) {
  const { compareFn = defaultCompare } = options
  return computed(() => sortFn(unref(arr), compareFn as UseSortCompareFn<T>))
}

// useQuickSort/index.ts
import type { MaybeRef } from '@vueuse/shared'
import type { UseSortCompareFn, UseSortOptions } from '../useSort'
import { useSort } from '../useSort'

export function quickSort<T>(arr: T[], compareFn: UseSortCompareFn<T>): T[] {
  // sorted
  if (arr.length <= 1) return arr

  const pivot = arr[0]
  const centerArr: T[] = [pivot]
  const left: T[] = []
  const right: T[] = []

  for (let i = 1; i < arr.length; i++) {
    const element = arr[i]
    const compare = compareFn(element, pivot)
    if (compare === 0)
      centerArr.push(element)
    else if (compare < 0)
      left.push(element)
    else
      right.push(element)
  }

  return quickSort(left, compareFn).concat(centerArr, quickSort(right, compareFn))
}

export function useQuickSort<T>(arr: MaybeRef<T[]>, options: UseSortOptions<T> = {}) {
  return useSort(arr, quickSort, options)
}

Alternative

No response

Additional context

No response

Validations

• Follow our Code of Conduct
• Read the Contributing Guidelines.
• Read the docs.
• Check that there isn't already an issue that request the same feature to avoid creating a duplicate.

[mdbetancourt]

why not just use one function with algorithm as an option

useSort(arr, { algorithm: quicksort })

[wheatjs]

I'd prefer the initial implementation. I think it is more composable that way, similar to how we have useStorage, useLocalStorage, and useSessionStorage

[mdbetancourt]

I'd prefer the initial implementation. I think it is more composable that way, similar to how we have useStorage, useLocalStorage, and useSessionStorage

we have only a few storage options but sort algorithms.. there is at least 40+ different options

[wheatjs]

Sure but the current implementation supports providing a custom algorithm in useSort as the second parameter. Seems unlikely that we would end up providing the 40+ different algorithms. I think providing the base function along with a few common sorting algorithms is the best option.

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.