@stacksjs/utils 0.58.48 → 0.58.49

package/dist/index.js

@@ -884,7 +884,7 @@ function prettyBytes(number, options) {
   return prefix + numberString + separator + unit;
 }
 // package.json
-var version = "0.58.48";
+var version = "0.58.49";
 export {
   wordChar,
   wordBoundary,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/utils",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks helper functions.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -42,7 +42,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/base.ts

@@ -0,0 +1,12 @@
+export { toString } from '@stacksjs/strings'
+
+export function assert(condition: boolean, message: string): asserts condition {
+  if (!condition)
+    throw new Error(message)
+}
+
+// export function noop() {}
+
+export async function loop(times: number, callback: any) {
+  [...Array(times)].forEach(async (item, i) => await callback(i))
+}

package/src/clean.ts

@@ -0,0 +1,17 @@
+import { path as p } from '@stacksjs/path'
+import { rimraf } from './delete'
+
+export async function cleanProject() {
+  return await rimraf([
+    p.projectPath('bun.lockb'),
+    p.projectPath('yarn.lock'),
+    p.projectPath('node_modules/'),
+    p.frameworkPath('dist'),
+    p.frameworkPath('node_modules'),
+    p.frameworkPath('**/dist'),
+    p.frameworkPath('**/node_modules'),
+    p.cloudPath('cdk.out/'),
+    p.cloudPath('cdk.context.json'),
+    p.cloudPath('dist.zip'),
+  ])
+}

package/src/config.ts

@@ -0,0 +1,25 @@
+export {
+  defineApp,
+  defineCache,
+  defineCli,
+  defineCdn,
+  defineCronJob,
+  defineJob,
+  defineDependencies,
+  defineDatabase,
+  defineDns,
+  defineEmailConfig,
+  defineGit,
+  defineHashing,
+  defineLibrary,
+  defineNotification,
+  defineSms,
+  defineEmail,
+  defineChat,
+  definePayment,
+  defineQueue,
+  defineSearchEngine,
+  defineServices,
+  defineStorage,
+  defineUi,
+} from '@stacksjs/config'

package/src/currency.ts

@@ -0,0 +1,29 @@
+export {
+  add,
+  allocate,
+  compare,
+  convert,
+  equal,
+  greaterThan,
+  greaterThanOrEqual,
+  hasSubUnits,
+  isZero,
+  lessThan,
+  lessThanOrEqual,
+  maximum,
+  minimum,
+  multiply,
+  normalizeScale,
+  dinero,
+  dinero as money,
+  subtract,
+  toSnapshot,
+  toUnits,
+  toDecimal,
+  trimScale,
+  haveSameCurrency,
+  haveSameAmount,
+  dinero as currency,
+} from 'dinero.js'
+export { USD } from '@dinero.js/currencies'
+export type { Dinero, Currency } from 'dinero.js'

package/src/debounce.ts

@@ -0,0 +1 @@
+export { debounce } from 'perfect-debounce'

package/src/delete.ts

@@ -0,0 +1 @@
+export { rimraf } from 'rimraf'

package/src/equal.ts

@@ -0,0 +1,27 @@
+import { getTypeName } from '@stacksjs/types'
+
+export function isDeepEqual(value1: any, value2: any): boolean {
+  const type1 = getTypeName(value1)
+  const type2 = getTypeName(value2)
+  if (type1 !== type2)
+    return false
+
+  if (type1 === 'array') {
+    if (value1.length !== value2.length)
+      return false
+
+    return value1.every((item: any, i: number) => {
+      return isDeepEqual(item, value2[i])
+    })
+  }
+  if (type1 === 'object') {
+    const keyArr = Object.keys(value1)
+    if (keyArr.length !== Object.keys(value2).length)
+      return false
+
+    return keyArr.every((key: string) => {
+      return isDeepEqual(value1[key], value2[key])
+    })
+  }
+  return Object.is(value1, value2)
+}

package/src/export-size.ts

@@ -0,0 +1 @@
+export { getExportsSize } from 'export-size'

package/src/function.ts

@@ -0,0 +1,32 @@
+import type { Fn, Nullable } from '@stacksjs/types'
+
+/**
+ * Call every function in an array
+ */
+export function batchInvoke(functions: Nullable<Fn>[]) {
+  functions.forEach(fn => fn && fn())
+}
+
+// /**
+//  * Call the function
+//  */
+// export function invoke(fn: Fn) {
+//   return fn()
+// }
+
+/**
+ * Pass the value through the callback, and return the value
+ *
+ * @example
+ * ```
+ * function createUser(name: string): User {
+ *   return tap(new User, user => {
+ *     user.name = name
+ *   })
+ * }
+ * ```
+ */
+export function tap<T>(value: T, callback: (value: T) => void): T {
+  callback(value)
+  return value
+}

package/src/git.ts

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process'
+
+export function isGitClean() {
+  try {
+    execSync('git diff-index --quiet HEAD --')
+    return true
+  }
+  catch (error) {
+    return false
+  }
+}

package/src/glob.ts

@@ -0,0 +1 @@
+export { glob } from '@stacksjs/storage'

package/src/guards.ts

@@ -0,0 +1,39 @@
+/**
+ * Type guard to filter out null-ish values
+ *
+ * @category Guards
+ * @example array.filter(notNullish)
+ */
+export function notNullish<T>(v: T | null | undefined): v is NonNullable<T> {
+  return v != null
+}
+
+/**
+ * Type guard to filter out null values
+ *
+ * @category Guards
+ * @example array.filter(noNull)
+ */
+export function noNull<T>(v: T | null): v is Exclude<T, null> {
+  return v !== null
+}
+
+/**
+ * Type guard to filter out null-ish values
+ *
+ * @category Guards
+ * @example array.filter(notUndefined)
+ */
+export function notUndefined<T>(v: T): v is Exclude<T, undefined> {
+  return v !== undefined
+}
+
+/**
+ * Type guard to filter out falsy values
+ *
+ * @category Guards
+ * @example array.filter(isTruthy)
+ */
+export function isTruthy<T>(v: T): v is NonNullable<T> {
+  return Boolean(v)
+}

package/src/hash.ts

@@ -0,0 +1,17 @@
+import { hashPaths } from '@stacksjs/storage'
+import { path as p } from '@stacksjs/path'
+import { config } from '@stacksjs/config'
+
+export const originRequestFunctionHash = hashPaths(p.cloudPath('src/edge'))
+
+const docsSrc = [
+  p.projectPath('docs'),
+  p.projectPath('config/docs.ts'),
+]
+
+const websiteSrc = [
+  p.projectPath('resources/views'),
+  // p.projectPath('config/app.ts'),
+]
+
+export const websiteSourceHash = config.app.docMode === true ? hashPaths(docsSrc) : hashPaths(websiteSrc)

package/src/helpers.ts

@@ -0,0 +1,187 @@
+import type { AddressInfo } from 'node:net'
+
+// import { runAction } from '@stacksjs/actions'
+import { log, runCommand } from '@stacksjs/cli'
+import type { Result } from '@stacksjs/error-handling'
+import { err, handleError, ok } from '@stacksjs/error-handling'
+import { frameworkPath, projectPath } from '@stacksjs/path'
+import * as storage from '@stacksjs/storage'
+import type { CliOptions, Manifest, StacksError, SyncSubprocess } from '@stacksjs/types'
+import type { NpmScript } from '@stacksjs/enums'
+import { Action } from '@stacksjs/enums'
+import { parse } from 'yaml'
+
+// import { semver } from './versions'
+import { app, ui } from '@stacksjs/config'
+
+export async function packageManager() {
+  const { packageManager } = await storage.readPackageJson(frameworkPath('package.json'))
+  return packageManager
+}
+
+export async function initProject(): Promise<Result<SyncSubprocess, StacksError>> {
+  if (app.env !== 'production')
+    log.info('Project not yet initialized, generating application key...')
+  else
+    handleError('Please run `buddy key:generate` to generate an application key')
+
+  const result = await runAction(Action.KeyGenerate, { cwd: projectPath() })
+
+  if (result.isErr())
+    return err(handleError(result.error))
+
+  log.info('Application key generated.')
+
+  return ok(result.value)
+}
+
+export async function ensureProjectIsInitialized() {
+  if (storage.isFile(projectPath('.env')))
+    return await isAppKeySet()
+
+  // copy the .env.example file to .env
+  if (storage.isFile(projectPath('.env.example')))
+    await runCommand('cp .env.example .env', { cwd: projectPath() })
+  else
+    console.error('no .env.example file found')
+
+  return await isAppKeySet()
+}
+
+export async function installIfVersionMismatch() {
+  // const requiredBunVersion = '0.8.1'
+  // const installedBunVersion = process.version
+
+  // if (!semver.satisfies(installedBunVersion, requiredBunVersion)) {
+  //   log.warn(`Installed Bun version ${italic(installedBunVersion)} does not satisfy required version ${italic(requiredBunVersion)}. Adding it to your environment. One moment...`)
+  //   await runCommand(`tea +bun.sh${requiredBunVersion} >/dev/null 2>&1`)
+  // }
+}
+
+export async function frameworkVersion(): Promise<string> {
+  return (await storage.readPackageJson(frameworkPath('package.json'))).version
+}
+
+export async function isAppKeySet() {
+  const env = await storage.readTextFile('.env', projectPath())
+  const lines = env.data.split('\n')
+  const appKey = lines.find(line => line.startsWith('APP_KEY='))
+
+  return !!(appKey && appKey.length > 16)
+}
+
+/**
+ * Determines the utilized reset preset.
+ *
+ * @url https://www.npmjs.com/package/@unocss/reset
+ * @param preset
+ */
+export function determineResetPreset(preset?: string) {
+  if (ui.reset)
+    preset = ui.reset
+
+  if (preset === 'tailwind')
+    return ['import \'@unocss/reset/tailwind.css\'']
+
+  if (preset === 'normalize')
+    return ['import \'@unocss/reset/normalize.css\'']
+
+  if (preset === 'sanitize')
+    return ['import \'@unocss/reset/sanitize/sanitize.css\'', 'import \'@unocss/reset/sanitize/assets.css']
+
+  if (preset === 'eric-meyer')
+    return ['import \'@unocss/reset/eric-meyer.css\'']
+
+  if (preset === 'antfu')
+    return ['import \'@unocss/reset/antfu.css\'']
+
+  return []
+}
+
+/**
+ * Determines whether the specified value is a package manifest.
+ */
+export function isManifest(obj: any): obj is Manifest {
+  return obj
+    && typeof obj === 'object'
+    && isOptionalString(obj.name)
+    && isOptionalString(obj.version)
+    && isOptionalString(obj.description)
+}
+
+/**
+ * Determines whether the specified value is a string, null, or undefined.
+ */
+export function isOptionalString(value: any): value is string | undefined {
+  const type = typeof value
+  return value === null
+    || type === 'undefined'
+    || type === 'string'
+}
+
+export async function setEnvValue(key: string, value: string) {
+  const file = await storage.readTextFile(projectPath('.env'))
+
+  await storage.writeTextFile({
+    path: projectPath('.env'),
+    data: file.data.replace(/APP_KEY=/g, `APP_KEY=${value}`), // todo: do not hardcode the APP_KEY here and instead use the key parameter
+  })
+}
+
+/**
+ * Runs the specified NPM script in the package.json file.
+ */
+export async function runNpmScript(script: NpmScript, options?: CliOptions): Promise<Result<SyncSubprocess, StacksError>> {
+  const { data: manifest } = await storage.readJsonFile('package.json', frameworkPath())
+
+  if (isManifest(manifest) && hasScript(manifest, script)) // simple, yet effective check to see if the script exists
+    return await runCommand(`bun --bun run ${script}`, options)
+
+  return err(handleError(`The ${script} script does not exist in the package.json file.`))
+}
+
+/**
+ * Determines whether the specified NPM script exists in the given manifest.
+ */
+export function hasScript(manifest: Manifest, script: NpmScript): boolean {
+  const scripts = manifest.scripts as Record<NpmScript, string> | undefined
+
+  if (scripts && typeof scripts === 'object')
+    return Boolean(scripts[script])
+
+  return false
+}
+
+export function parseYaml(content: any) {
+  return parse(content)
+}
+
+/**
+ * Determines the level of debugging.
+ *
+ * The debug level is determined by the following:
+ * 1. The --verbose flag
+ * 2. The debug property in the app configuration
+ *
+ * Currently, we don't support a custom debug level,
+ * though, we would like to in the future.
+ *
+ * @param options
+ */
+export function determineDebugLevel(options?: CliOptions) {
+  if (options?.verbose === true)
+    return true
+
+  return app.debug === true
+}
+
+export function isIpv6(address: AddressInfo): boolean {
+  return address.family === 'IPv6'
+  // in node >=18.0 <18.4 this was an integer value. This was changed in a minor version.
+  // See: https://github.com/laravel/vite-plugin/issues/103
+
+  // @ts-expect-error-next-line
+    || address.family === 6
+}
+
+export { dump as dumpYaml, load as loadYaml } from 'js-yaml'

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from './base'
+export * from './clean'
+export * from './config'
+export * from './currency'
+export * from './debounce'
+export * from './delete'
+export * from './equal'
+export * from './export-size'
+export * from './function'
+export * from './git'
+export * from './guards'
+export * from './hash'
+export * from './helpers'
+export * from './macroable'
+export * from './math'
+export * from './p'
+export * from './promise'
+export * from './regex'
+export * from './sleep'
+export * from './throttle'
+export * from './vendors'
+export * from './versions'

package/src/macroable.ts

@@ -0,0 +1 @@
+export { Macroable } from 'macroable'

package/src/math.ts

@@ -0,0 +1,30 @@
+export const clamp = (n: number, min: number, max: number) => Math.min(max, Math.max(min, n))
+
+export function rand(min: number, max: number) {
+  min = Math.ceil(min)
+  max = Math.floor(max)
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+// not, -> exported as well in ../regex
+export {
+  and,
+  createGenericProjection,
+  createProjection,
+  logicNot,
+  logicOr,
+  or,
+  useAbs,
+  useAverage,
+  useCeil,
+  useClamp,
+  useFloor,
+  useMath,
+  useMax,
+  useMin,
+  usePrecision,
+  useProjection,
+  useRound,
+  useSum,
+  useTrunc,
+} from '@vueuse/math'

package/src/p.ts

@@ -0,0 +1,119 @@
+import pLimit from 'p-limit'
+
+/**
+ * Internal marker for filtered items
+ */
+const VOID = Symbol('p-void')
+
+interface POptions {
+  /**
+   * How many promises are resolved at the same time.
+   */
+  concurrency?: number | undefined
+}
+
+class PInstance<T = any> extends Promise<Awaited<T>[]> {
+  private promises = new Set<T | Promise<T>>()
+
+  get promise(): Promise<Awaited<T>[]> {
+    let batch
+    const items = [...Array.from(this.items), ...Array.from(this.promises)]
+
+    if (this.options?.concurrency) {
+      const limit = pLimit(this.options.concurrency)
+      batch = Promise.all(items.map(p => limit(() => p)))
+    }
+    else {
+      batch = Promise.all(items)
+    }
+
+    return batch.then(l => l.filter((i: any) => i !== VOID))
+  }
+
+  constructor(public items: Iterable<T> = [], public options?: POptions) {
+    super(() => {})
+  }
+
+  add(...args: (T | Promise<T>)[]) {
+    args.forEach((i) => {
+      this.promises.add(i)
+    })
+  }
+
+  map<U>(fn: (value: Awaited<T>, index: number) => U): PInstance<Promise<U>> {
+    return new PInstance(
+      Array.from(this.items)
+        .map(async (i, idx) => {
+          const v = await i
+          if ((v as any) === VOID)
+            return VOID as unknown as U
+          return fn(v, idx)
+        }),
+      this.options,
+    )
+  }
+
+  filter(fn: (value: Awaited<T>, index: number) => boolean | Promise<boolean>): PInstance<Promise<T>> {
+    return new PInstance(
+      Array.from(this.items)
+        .map(async (i, idx) => {
+          const v = await i
+          const r = await fn(v, idx)
+          if (!r)
+            return VOID as unknown as T
+          return v
+        }),
+      this.options,
+    )
+  }
+
+  forEach(fn: (value: Awaited<T>, index: number) => void): Promise<void> {
+    return this.map(fn).then()
+  }
+
+  reduce<U>(fn: (previousValue: U, currentValue: Awaited<T>, currentIndex: number, array: Awaited<T>[]) => U, initialValue: U): Promise<U> {
+    return this.promise.then(array => array.reduce(fn, initialValue))
+  }
+
+  clear() {
+    this.promises.clear()
+  }
+
+  then(fn?: () => PromiseLike<any>) {
+    const p = this.promise
+
+    if (fn)
+      return p.then(fn)
+
+    return p
+  }
+
+  catch(fn?: (err: unknown) => PromiseLike<any>) {
+    return this.promise.catch(fn)
+  }
+
+  finally(fn?: () => void) {
+    return this.promise.finally(fn)
+  }
+}
+
+/**
+ * Utility for managing multiple promises.
+ *
+ * @see https://github.com/antfu/utils/tree/main/docs/p.md
+ * @category Promise
+ * @example
+ * ```
+ * import { p } from '@stacksjs/utils'
+ *
+ * const items = [1, 2, 3, 4, 5]
+ *
+ * await p(items)
+ *   .map(async i => await multiply(i, 3))
+ *   .filter(async i => await isEven(i))
+ * // [6, 12]
+ * ```
+ */
+export function p<T = any>(items?: Iterable<T>, options?: POptions): PInstance<T> {
+  return new PInstance(items, options)
+}

package/src/promise.ts

@@ -0,0 +1,117 @@
+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, 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

@@ -0,0 +1,2 @@
+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/sleep.ts

@@ -0,0 +1,60 @@
+/**
+ * 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: number = 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: number = 1000): Promise<void> {
+  return new Promise((resolve) => {
+    const check = setInterval(() => {
+      if (!condition()) {
+        clearInterval(check)
+        resolve()
+      }
+    }, interval)
+  })
+}

package/src/throttle.ts

@@ -0,0 +1,44 @@
+/**
+ * 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

@@ -0,0 +1,258 @@
+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'

package/src/versions.ts

@@ -0,0 +1,6 @@
+import { version } from '../package.json'
+
+// import { semver } from 'bun'
+
+export { version }
+// export { version, semver }