File size: 2,008 Bytes
dc06ee7 376f172 dc06ee7 376f172 3578090 5068375 376f172 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
import { clsx, type ClassValue } from 'clsx'
import { twMerge } from 'tailwind-merge'
import { StoreApi, UseBoundStore } from 'zustand'
export function cn(...inputs: ClassValue[]) {
return twMerge(clsx(inputs))
}
export function randomColor() {
const digits = '0123456789abcdef'
let code = '#'
for (let i = 0; i < 6; i++) {
code += digits.charAt(Math.floor(Math.random() * 16))
}
return code
}
export function errorMessage(error: any) {
return error instanceof Error ? error.message : `${error}`
}
/**
* Creates a throttled function that limits how often the original function can be called
* @param fn The function to throttle
* @param delay The delay in milliseconds
* @returns A throttled version of the function
*/
export function throttle<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void {
let lastCall = 0
let timeoutId: ReturnType<typeof setTimeout> | null = null
return function(this: any, ...args: Parameters<T>) {
const now = Date.now()
const remaining = delay - (now - lastCall)
if (remaining <= 0) {
// If enough time has passed, execute the function immediately
if (timeoutId) {
clearTimeout(timeoutId)
timeoutId = null
}
lastCall = now
fn.apply(this, args)
} else if (!timeoutId) {
// If not enough time has passed, set a timeout to execute after the remaining time
timeoutId = setTimeout(() => {
lastCall = Date.now()
timeoutId = null
fn.apply(this, args)
}, remaining)
}
}
}
type WithSelectors<S> = S extends { getState: () => infer T }
? S & { use: { [K in keyof T]: () => T[K] } }
: never
export const createSelectors = <S extends UseBoundStore<StoreApi<object>>>(_store: S) => {
const store = _store as WithSelectors<typeof _store>
store.use = {}
for (const k of Object.keys(store.getState())) {
;(store.use as any)[k] = () => store((s) => s[k as keyof typeof s])
}
return store
}
|