@stacksjs/utils 0.64.5 → 0.65.0

package/src/promise.ts

@@ -1,116 +0,0 @@
-import { remove } from '@stacksjs/arrays'
-
-export interface SingletonPromiseReturn<T> {
-  (): Promise<T>
-  /**
-   * Reset current staled promise.
-   * Await it to have proper shutdown.
-   */
-  reset: () => Promise<void>
-}
-
-// export { peek } from 'bun'
-
-/**
- * Promise with `resolve` and `reject` methods of itself
- */
-export interface ControlledPromise<T = void> extends Promise<T> {
-  resolve: (value: T | PromiseLike<T>) => void
-  reject: (reason?: any) => void
-}
-
-/**
- * Create singleton promise function.
- *
- * @category Promise
- */
-export function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T> {
-  let _promise: Promise<T> | undefined
-
-  function wrapper() {
-    if (!_promise) _promise = fn()
-    return _promise
-  }
-  wrapper.reset = async () => {
-    const _prev = _promise
-    _promise = undefined
-    if (_prev) await _prev
-  }
-
-  return wrapper
-}
-
-/**
- * Create a promise lock.
- *
- * @category Promise
- * @example
- * ```
- * const lock = createPromiseLock()
- *
- * lock.run(async () => {
- *   await doSomething()
- * })
- *
- * // in anther context:
- * await lock.wait() // it will wait all tasking finished
- * ```
- */
-export function createPromiseLock() {
-  const locks: Promise<any>[] = []
-
-  return {
-    async run<T = void>(fn: () => Promise<T>): Promise<T> {
-      const p = fn()
-      locks.push(p)
-      try {
-        return await p
-      } finally {
-        remove(locks, p)
-      }
-    },
-    async wait(): Promise<void> {
-      await Promise.allSettled(locks)
-    },
-    isWaiting() {
-      return Boolean(locks.length)
-    },
-    clear() {
-      locks.length = 0
-    },
-  }
-}
-
-/**
- * Return a Promise with `resolve` and `reject` methods
- *
- * @category Promise
- * @example
- * ```
- * const promise = createControlledPromise()
- *
- * await promise
- *
- * // in anther context:
- * promise.resolve(data)
- * ```
- */
-export function createControlledPromise<T>(): ControlledPromise<T> {
-  let resolve: any
-  let reject: any
-
-  const promise = new Promise<T>((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  }) as ControlledPromise<T>
-
-  promise.resolve = resolve
-
-  promise.reject = reject
-  return promise
-}
-
-/**
- * Create a promise that will be resolved after `ms` milliseconds.
- */
-// export { sleep, sleepSync } from 'bun'

package/src/regex.ts

@@ -1,35 +0,0 @@
-export type {
-  Flag,
-  MagicRegExp,
-  MagicRegExpMatchArray,
-  Input,
-  MapToStringCapturedBy,
-  StringCapturedBy,
-} from 'magic-regexp'
-export {
-  createRegExp,
-  caseInsensitive,
-  anyOf,
-  carriageReturn,
-  char,
-  charIn,
-  charNotIn,
-  digit,
-  dotAll,
-  exactly,
-  global,
-  letter,
-  linefeed,
-  maybe,
-  multiline,
-  not,
-  oneOrMore,
-  sticky,
-  tab,
-  unicode,
-  whitespace,
-  withIndices,
-  word,
-  wordBoundary,
-  wordChar,
-} from 'magic-regexp'

package/src/retry.ts

@@ -1,36 +0,0 @@
-export function retry(fn: Function, options: any): Promise<any> {
-  const { retries = 3, initialDelay = 1000, backoffFactor = 2, jitter = true } = options
-
-  return new Promise((resolve, reject) => {
-    let attemptCount = 0
-    const attempt = async () => {
-      try {
-        resolve(await fn())
-      } catch (err) {
-        if (attemptCount >= retries) {
-          reject(err)
-        } else {
-          const delay = calculateDelay(attemptCount, initialDelay, backoffFactor, jitter)
-          setTimeout(() => attempt(), delay)
-          attemptCount++
-        }
-      }
-    }
-    attempt()
-  })
-}
-
-export function calculateDelay(
-  attemptCount: number,
-  initialDelay: number,
-  backoffFactor: number,
-  jitter?: boolean,
-): number {
-  let delay = initialDelay * backoffFactor ** attemptCount
-  if (jitter) {
-    const random = Math.random() // Generates a number between 0 and 1
-    const jitterValue = delay * 0.3 // Jitter will be up to 30% of the delay
-    delay = delay + jitterValue * (random - 0.5) * 2 // Adjust delay randomly within ±30%
-  }
-  return delay
-}

package/src/sleep.ts

@@ -1,60 +0,0 @@
-/**
- * Pauses execution for a specified number of milliseconds.
- * @param ms The number of milliseconds to pause execution.
- * @returns A promise that resolves after the specified delay.
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Pauses execution for a specified number of milliseconds.
- * @param ms The number of milliseconds to pause execution.
- * @returns A promise that resolves after the specified delay.
- */
-export function wait(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Pauses execution for a specified number of milliseconds.
- * @param ms The number of milliseconds to pause execution.
- * @returns A promise that resolves after the specified delay.
- */
-export function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Pauses execution until a specified condition is met.
- * @param condition The condition to wait for.
- * @param interval The interval at which to check the condition, in milliseconds. Defaults to 1000.
- * @returns A promise that resolves when the condition is met.
- */
-export function waitUntil(condition: () => boolean, interval = 1000): Promise<void> {
-  return new Promise((resolve) => {
-    const check = setInterval(() => {
-      if (condition()) {
-        clearInterval(check)
-        resolve()
-      }
-    }, interval)
-  })
-}
-
-/**
- * Pauses execution while a specified condition is met.
- * @param condition The condition to wait while.
- * @param interval The interval at which to check the condition, in milliseconds. Defaults to 1000.
- * @returns A promise that resolves when the condition is no longer met.
- */
-export function waitWhile(condition: () => boolean, interval = 1000): Promise<void> {
-  return new Promise((resolve) => {
-    const check = setInterval(() => {
-      if (!condition()) {
-        clearInterval(check)
-        resolve()
-      }
-    }, interval)
-  })
-}

package/src/throttle.ts

@@ -1,46 +0,0 @@
-/**
- * Throttle a function.
- *
- * @param {Function} fn - The function to throttle.
- * @param {number} [wait] - The time to wait between function calls.
- * @returns {Function} - A new function that throttles the calls to the original function.
- *
- * @example
- * ```ts
- * // logs window dimensions at most every 250ms
- * window.addEventListener(
- *   "resize",
- *   throttle(function (evt) {
- *     console.log(window.innerWidth)
- *     console.log(window.innerHeight)
- *   }, 250)
- * )
- * ```
- */
-
-export function throttle(fn: Function, wait = 300) {
-  let inThrottle: boolean
-  let lastFn: ReturnType<typeof setTimeout>
-  let lastTime: number
-
-  return function (this: unknown, ...args: any[]) {
-    if (!inThrottle) {
-      fn.apply(this, args)
-
-      lastTime = Date.now()
-      inThrottle = true
-    } else {
-      clearTimeout(lastFn)
-
-      lastFn = setTimeout(
-        () => {
-          if (Date.now() - lastTime >= wait) {
-            fn.apply(this, args) // Use 'this' directly
-            lastTime = Date.now()
-          }
-        },
-        Math.max(wait - (Date.now() - lastTime), 0),
-      )
-    }
-  }
-}

package/src/vendors.ts

@@ -1,258 +0,0 @@
-export {
-  asyncComputed,
-  breakpointsAntDesign,
-  breakpointsBootstrapV5,
-  breakpointsMasterCss,
-  breakpointsQuasar,
-  breakpointsSematic,
-  breakpointsTailwind,
-  breakpointsVuetify,
-  cloneFnJSON,
-  computedAsync,
-  computedInject,
-  createFetch,
-  createReusableTemplate,
-  createTemplatePromise,
-  createUnrefFn,
-  customStorageEventName,
-  defaultDocument,
-  defaultLocation,
-  defaultNavigator,
-  defaultWindow,
-  executeTransition,
-  formatTimeAgo,
-  getSSRHandler,
-  mapGamepadToXbox360Controller,
-  onClickOutside,
-  onKeyDown,
-  onKeyPressed,
-  onKeyStroke,
-  onKeyUp,
-  onLongPress,
-  onStartTyping,
-  setSSRHandler,
-  templateRef,
-  unrefElement,
-  useActiveElement,
-  useAnimate,
-  useAsyncQueue,
-  useAsyncState,
-  useBase64,
-  useBattery,
-  useBluetooth,
-  useBreakpoints,
-  useBroadcastChannel,
-  useBrowserLocation,
-  useCached,
-  useClipboard,
-  useCloned,
-  useColorMode,
-  useConfirmDialog,
-  useCssVar,
-  useCurrentElement,
-  useCycleList,
-  useDark,
-  useDebouncedRefHistory,
-  useDeviceMotion,
-  useDeviceOrientation,
-  useDevicePixelRatio,
-  useDevicesList,
-  useDisplayMedia,
-  useDocumentVisibility,
-  useDraggable,
-  useDropZone,
-  useElementBounding,
-  useElementByPoint,
-  useElementHover,
-  useElementSize,
-  useElementVisibility,
-  useEventBus,
-  useEventListener,
-  useEventSource,
-  useEyeDropper,
-  useFavicon,
-  useFetch,
-  useFileDialog,
-  useFileSystemAccess,
-  useFocus,
-  useFocusWithin,
-  useFps,
-  useFullscreen,
-  useGamepad,
-  useGeolocation,
-  useIdle,
-  useImage,
-  useInfiniteScroll,
-  useIntersectionObserver,
-  useKeyModifier,
-  useLocalStorage,
-  useMagicKeys,
-  useManualRefHistory,
-  useMediaControls,
-  useMediaQuery,
-  useMemoize,
-  useMemory,
-  useMounted,
-  useMouse,
-  useMouseInElement,
-  useMousePressed,
-  useMutationObserver,
-  useNavigatorLanguage,
-  useNetwork,
-  useObjectUrl,
-  useOffsetPagination,
-  useOnline,
-  usePageLeave,
-  useParallax,
-  useParentElement,
-  usePerformanceObserver,
-  usePermission,
-  usePointer,
-  usePointerLock,
-  usePointerSwipe,
-  usePreferredColorScheme,
-  usePreferredContrast,
-  usePreferredDark,
-  usePreferredLanguages,
-  usePreferredReducedMotion,
-  usePrevious,
-  useRafFn,
-  useRefHistory,
-  useResizeObserver,
-  useScreenOrientation,
-  useScreenSafeArea,
-  useScriptTag,
-  useScroll,
-  useScrollLock,
-  useSessionStorage,
-  useShare,
-  useSorted,
-  useSpeechRecognition,
-  useSpeechSynthesis,
-  useStepper,
-  useStorage,
-  useStorageAsync,
-  useStyleTag,
-  useSupported,
-  useSwipe,
-  useTemplateRefsList,
-  useTextDirection,
-  useTextSelection,
-  useTextareaAutosize,
-  useThrottledRefHistory,
-  useTimeAgo,
-  useTimeoutPoll,
-  useTimestamp,
-  useTitle,
-  useTransition,
-  useToggle,
-  useUrlSearchParams,
-  useUserMedia,
-  useVModel,
-  useVModels,
-  useVibrate,
-  useVirtualList,
-  useWakeLock,
-  useWebNotification,
-  useWebSocket,
-  useWebWorker,
-  useWebWorkerFn,
-  useWindowFocus,
-  useWindowScroll,
-  useWindowSize,
-  useDateFormat,
-  useNow,
-  watchArray,
-  watchAtMost,
-  watchDebounced,
-  watchDeep,
-  watchIgnorable,
-  watchImmediate,
-  watchOnce,
-  watchPausable,
-  watchThrottled,
-  watchTriggerable,
-  watchWithFilter,
-  whenever,
-  syncRef,
-  syncRefs,
-  throttledRef,
-  throttledWatch,
-  toReactive,
-  tryOnBeforeMount,
-  tryOnBeforeUnmount,
-  tryOnMounted,
-  tryOnScopeDispose,
-  tryOnUnmounted,
-  until,
-  isDefined,
-  ignorableWatch,
-  extendRef,
-  eagerComputed,
-  debouncedRef,
-  debouncedWatch,
-  createReactiveFn,
-  createSharedComposable,
-  createInjectionState,
-  createGlobalState,
-  createEventHook,
-  controlledRef,
-  controlledComputed,
-  computedEager,
-  computedWithControl,
-  autoResetRef,
-  injectLocal,
-  makeDestructurable,
-  pausableWatch,
-  provideLocal,
-  reactify,
-  reactifyObject,
-  reactiveComputed,
-  reactiveOmit,
-  reactivePick,
-  refAutoReset,
-  refDebounced,
-  refDefault,
-  refThrottled,
-  refWithControl,
-  resolveRef,
-  resolveUnref,
-  useArrayDifference,
-  useArrayEvery,
-  useArrayFilter,
-  useArrayFind,
-  useArrayFindIndex,
-  useArrayIncludes,
-  useArrayMap,
-  useArrayReduce,
-  useArraySome,
-  useArrayUnique,
-  useClipboardItems,
-  useCounter,
-  useDebounce,
-  useDebounceFn,
-  useInterval,
-  useIntervalFn,
-  useLastChanged,
-  useThrottle,
-  useThrottleFn,
-  useTimeout,
-  useTimeoutFn,
-  useToNumber,
-  useToString,
-} from '@vueuse/core'
-
-export type {
-  // Head,
-  HeadObject,
-  HeadObjectPlain,
-} from '@vueuse/head'
-
-export {
-  Head,
-  HeadVuePlugin,
-  createHead,
-  renderHeadToString,
-} from '@vueuse/head'
-
-export { default as readableSize } from 'pretty-bytes'