stacks 0.58.73 → 0.59.2

package/core/utils/src/helpers.ts

@@ -1,187 +0,0 @@
-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, 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, Error>> {
-  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, Error>> {
-  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/core/utils/src/index.ts

@@ -1,24 +0,0 @@
-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 './find'
-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 './retry'
-export * from './sleep'
-export * from './throttle'
-export * from './vendors'
-export * from './versions'

package/core/utils/src/macroable.ts

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

package/core/utils/src/math.ts

@@ -1,30 +0,0 @@
-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/core/utils/src/p.ts

@@ -1,119 +0,0 @@
-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/core/utils/src/promise.ts

@@ -1,117 +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, 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/core/utils/src/regex.ts

@@ -1,2 +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/core/utils/src/retry.ts

@@ -1,33 +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/core/utils/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: 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/core/utils/src/throttle.ts

@@ -1,44 +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))
-    }
-  }
-}