bsmnt 0.3.0 → 0.3.2

package/src/templates/next-webgl/lib/utils/README.md

@@ -1,40 +0,0 @@
-# Utils
-
-Pure utility functions organized by concern.
-
-Use explicit imports for clarity and better tree-shaking:
-
-```tsx
-import { clamp, lerp, mapRange } from '@/utils/math'
-import { slugify } from '@/utils/strings'
-import { generatePageMetadata } from '@/utils/metadata'
-import { tovw, torem, toem } from '@/utils/viewport'
-```
-
-## Modules
-
-| Module | Functions |
-|--------|-----------|
-| `math` | `clamp`, `lerp`, `mapRange`, `modulo`, `normalize`, `distance` |
-| `easings` | All easing functions (`easeOutCubic`, etc.) |
-| `viewport` | `tovw`, `torem`, `toem` |
-| `strings` | `slugify`, `mergeRefs`, `capitalizeFirstLetter` |
-| `metadata` | `generatePageMetadata` |
-
-## Common Patterns
-
-```tsx
-// Math
-clamp(0, value, 100)
-lerp(0, 100, 0.5) // → 50
-mapRange(0, 1000, scrollY, 0, 1)
-
-// Viewport units
-tovw(100, 50, 'desktop') // → "max(50px, 6.94vw)"
-tovw(16, undefined, 'mobile') // → "4.27vw"
-torem(24) // → "1.5rem"
-toem(16, 14) // → "1.14em"
-
-// SEO
-export const metadata = generatePageMetadata({ title: 'About' })
-```

package/src/templates/next-webgl/lib/utils/easings.ts

@@ -1,240 +0,0 @@
-/**
- * Easing Functions
- *
- * A complete collection of easing curves for animations.
- * All functions take a progress value (0-1) and return an eased value (0-1).
- *
- * @see https://easings.net for visual references
- *
- * @example
- * ```ts
- * import { easings, type EasingName } from '@/utils/easings'
- *
- * // Direct usage
- * const eased = easings.easeOutCubic(0.5)
- *
- * // With a variable easing name
- * const easingName: EasingName = 'easeInOutQuart'
- * const value = easings[easingName](progress)
- * ```
- *
- * ## Choosing an Easing
- *
- * | Category | Use Case |
- * |----------|----------|
- * | `easeOut*` | UI feedback, appearing elements (most common) |
- * | `easeIn*` | Exiting elements, building tension |
- * | `easeInOut*` | State transitions, loading indicators |
- * | `*Cubic/Quart` | Natural, balanced motion |
- * | `*Expo` | Dramatic, snappy motion |
- * | `*Elastic/Bounce` | Playful, attention-grabbing |
- */
-
-const pow = Math.pow
-const sqrt = Math.sqrt
-const sin = Math.sin
-const cos = Math.cos
-const PI = Math.PI
-
-// Easing constants
-const c1 = 1.70158
-const c2 = c1 * 1.525
-const c3 = c1 + 1
-const c4 = (2 * PI) / 3
-const c5 = (2 * PI) / 4.5
-
-/** Bounce out helper (used by bounce easings) */
-const bounceOut = (x: number): number => {
-  const n1 = 7.5625
-  const d1 = 2.75
-
-  if (x < 1 / d1) {
-    return n1 * x * x
-  }
-  if (x < 2 / d1) {
-    return n1 * (x - 1.5 / d1) * x + 0.75
-  }
-  if (x < 2.5 / d1) {
-    return n1 * (x - 2.25 / d1) * x + 0.9375
-  }
-  return n1 * (x - 2.625 / d1) * x + 0.984375
-}
-
-/**
- * Collection of easing functions.
- * Each function takes progress (0-1) and returns eased value (0-1).
- */
-export const easings = {
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Linear (no easing)
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** No easing - constant speed */
-  linear: (x: number): number => x,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Quadratic (power of 2)
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Slow start */
-  easeInQuad: (x: number): number => x * x,
-
-  /** Slow end */
-  easeOutQuad: (x: number): number => 1 - (1 - x) * (1 - x),
-
-  /** Slow start and end */
-  easeInOutQuad: (x: number): number =>
-    x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Cubic (power of 3) - Most commonly used
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Slow start, natural feel */
-  easeInCubic: (x: number): number => x * x * x,
-
-  /** Slow end, natural feel - great for UI interactions */
-  easeOutCubic: (x: number): number => 1 - pow(1 - x, 3),
-
-  /** Smooth start and end - great for transitions */
-  easeInOutCubic: (x: number): number =>
-    x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Quartic (power of 4)
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Slower start than cubic */
-  easeInQuart: (x: number): number => x * x * x * x,
-
-  /** Slower end than cubic */
-  easeOutQuart: (x: number): number => 1 - pow(1 - x, 4),
-
-  /** More pronounced ease than cubic */
-  easeInOutQuart: (x: number): number =>
-    x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Quintic (power of 5)
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Very slow start */
-  easeInQuint: (x: number): number => x * x * x * x * x,
-
-  /** Very slow end */
-  easeOutQuint: (x: number): number => 1 - pow(1 - x, 5),
-
-  /** Very pronounced ease */
-  easeInOutQuint: (x: number): number =>
-    x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Sinusoidal - Gentle, wave-like
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Gentle slow start */
-  easeInSine: (x: number): number => 1 - cos((x * PI) / 2),
-
-  /** Gentle slow end */
-  easeOutSine: (x: number): number => sin((x * PI) / 2),
-
-  /** Gentle ease both ends */
-  easeInOutSine: (x: number): number => -(cos(PI * x) - 1) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Exponential - Dramatic, snappy
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Dramatic slow start - almost stationary then fast */
-  easeInExpo: (x: number): number => (x === 0 ? 0 : pow(2, 10 * x - 10)),
-
-  /** Dramatic slow end - fast then almost stops */
-  easeOutExpo: (x: number): number => (x === 1 ? 1 : 1 - pow(2, -10 * x)),
-
-  /** Dramatic both ends */
-  easeInOutExpo: (x: number): number => {
-    if (x === 0) return 0
-    if (x === 1) return 1
-    if (x < 0.5) return pow(2, 20 * x - 10) / 2
-    return (2 - pow(2, -20 * x + 10)) / 2
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Circular - Based on circle quarter
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Circular slow start */
-  easeInCirc: (x: number): number => 1 - sqrt(1 - pow(x, 2)),
-
-  /** Circular slow end */
-  easeOutCirc: (x: number): number => sqrt(1 - pow(x - 1, 2)),
-
-  /** Circular both ends */
-  easeInOutCirc: (x: number): number =>
-    x < 0.5
-      ? (1 - sqrt(1 - pow(2 * x, 2))) / 2
-      : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Back - Overshoots then returns
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Pulls back before accelerating */
-  easeInBack: (x: number): number => c3 * x * x * x - c1 * x * x,
-
-  /** Overshoots target then settles */
-  easeOutBack: (x: number): number =>
-    1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2),
-
-  /** Pulls back, overshoots, settles */
-  easeInOutBack: (x: number): number =>
-    x < 0.5
-      ? (pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2
-      : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Elastic - Spring-like oscillation
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Wobbles at start */
-  easeInElastic: (x: number): number => {
-    if (x === 0) return 0
-    if (x === 1) return 1
-    return -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4)
-  },
-
-  /** Wobbles at end - great for attention */
-  easeOutElastic: (x: number): number => {
-    if (x === 0) return 0
-    if (x === 1) return 1
-    return pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1
-  },
-
-  /** Wobbles both ends */
-  easeInOutElastic: (x: number): number => {
-    if (x === 0) return 0
-    if (x === 1) return 1
-    if (x < 0.5) return -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2
-    return (pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5)) / 2 + 1
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Bounce - Ball bouncing effect
-  // ─────────────────────────────────────────────────────────────────────────────
-
-  /** Bounces at start */
-  easeInBounce: (x: number): number => 1 - bounceOut(1 - x),
-
-  /** Bounces at end - like a ball settling */
-  easeOutBounce: bounceOut,
-
-  /** Bounces both ends */
-  easeInOutBounce: (x: number): number =>
-    x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2,
-} as const
-
-/** All available easing function names */
-export type EasingName = keyof typeof easings
-
-/** An easing function signature */
-export type EasingFunction = (progress: number) => number

package/src/templates/next-webgl/lib/utils/fetch.ts

@@ -1,84 +0,0 @@
-/**
- * Fetch Utilities
- *
- * Wrapper around fetch that adds timeout protection to prevent hanging requests.
- * Use this for all external API calls to improve reliability.
- */
-
-export interface FetchWithTimeoutOptions extends RequestInit {
-  timeout?: number // Timeout in milliseconds (default: 10000ms)
-}
-
-/**
- * Fetch with automatic timeout protection
- *
- * @param url - The URL to fetch
- * @param options - Fetch options with optional timeout
- * @returns Promise<Response>
- * @throws AbortError if timeout is reached
- *
- * @example
- * ```ts
- * try {
- *   const response = await fetchWithTimeout('https://api.example.com/data', {
- *     timeout: 5000, // 5 second timeout
- *     method: 'POST',
- *     body: JSON.stringify(data)
- *   })
- *   const result = await response.json()
- * } catch (error) {
- *   if (error.name === 'AbortError') {
- *     console.error('Request timed out')
- *   }
- * }
- * ```
- */
-export async function fetchWithTimeout(
-  url: string,
-  options: FetchWithTimeoutOptions = {}
-): Promise<Response> {
-  const { timeout = 10000, signal: externalSignal, ...fetchOptions } = options
-
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), timeout)
-
-  // If an external signal is provided, listen to it and abort our controller
-  if (externalSignal) {
-    externalSignal.addEventListener("abort", () => controller.abort())
-  }
-
-  try {
-    const response = await fetch(url, {
-      ...fetchOptions,
-      signal: controller.signal,
-    })
-    return response
-  } finally {
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Fetch JSON with timeout protection
- *
- * Convenience wrapper that automatically parses JSON and handles errors
- *
- * @example
- * ```ts
- * const data = await fetchJSON<{ name: string }>('https://api.example.com/user', {
- *   timeout: 5000
- * })
- * ```
- */
-export async function fetchJSON<T = unknown>(
-  url: string,
-  options: FetchWithTimeoutOptions = {}
-): Promise<T> {
-  const response = await fetchWithTimeout(url, options)
-
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-  }
-
-  return response.json() as Promise<T>
-}

package/src/templates/next-webgl/lib/utils/global-css.d.ts

@@ -1 +0,0 @@
-declare module "@/lib/styles/index.css";

package/src/templates/next-webgl/lib/utils/math.ts

@@ -1,236 +0,0 @@
-/**
- * Math Utilities
- *
- * Pure mathematical functions with no side effects.
- * These are the building blocks for animations, layouts, and data transformations.
- *
- * @example
- * ```ts
- * import { clamp, lerp, mapRange } from '@/utils/math'
- *
- * // Constrain a value
- * const bounded = clamp(0, value, 100)
- *
- * // Interpolate between values
- * const mid = lerp(0, 100, 0.5) // 50
- *
- * // Map scroll position to opacity
- * const opacity = mapRange(0, 500, scrollY, 0, 1, true)
- * ```
- */
-
-/**
- * Constrains a value between a minimum and maximum.
- *
- * @param min - Lower bound
- * @param input - Value to constrain
- * @param max - Upper bound
- * @returns The clamped value
- *
- * @example
- * ```ts
- * clamp(0, -5, 100)  // 0
- * clamp(0, 50, 100)  // 50
- * clamp(0, 150, 100) // 100
- * ```
- */
-export function clamp(min: number, input: number, max: number): number {
-  return Math.max(min, Math.min(input, max))
-}
-
-/**
- * Linear interpolation between two values.
- *
- * @param start - Starting value
- * @param end - Ending value
- * @param amount - Interpolation factor (0 = start, 1 = end)
- * @returns The interpolated value
- *
- * @example
- * ```ts
- * lerp(0, 100, 0)    // 0
- * lerp(0, 100, 0.5)  // 50
- * lerp(0, 100, 1)    // 100
- * lerp(0, 100, 0.25) // 25
- * ```
- */
-export function lerp(start: number, end: number, amount: number): number {
-  return (1 - amount) * start + amount * end
-}
-
-/**
- * Maps a value from one range to another.
- *
- * @param inMin - Input range minimum
- * @param inMax - Input range maximum
- * @param input - Value to map
- * @param outMin - Output range minimum
- * @param outMax - Output range maximum
- * @param shouldClamp - Whether to clamp output to range (default: false)
- * @returns The mapped value
- *
- * @example
- * ```ts
- * // Map scroll (0-1000) to opacity (0-1)
- * mapRange(0, 1000, 500, 0, 1) // 0.5
- *
- * // Map with clamping (won't exceed bounds)
- * mapRange(0, 100, 150, 0, 1, true) // 1
- *
- * // Inverted ranges work too
- * mapRange(0, 100, 50, 1, 0) // 0.5
- * ```
- */
-export function mapRange(
-  inMin: number,
-  inMax: number,
-  input: number,
-  outMin: number,
-  outMax: number,
-  shouldClamp = false
-): number {
-  const result =
-    ((input - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin
-
-  if (!shouldClamp) return result
-
-  const isInverted = outMin > outMax
-  return isInverted
-    ? clamp(outMax, result, outMin)
-    : clamp(outMin, result, outMax)
-}
-
-/**
- * Truncates a number to a specified number of decimal places.
- *
- * @param value - Number to truncate
- * @param decimals - Number of decimal places
- * @returns The truncated number
- *
- * @example
- * ```ts
- * truncate(3.14159, 2) // 3.14
- * truncate(3.14159, 0) // 3
- * ```
- */
-export function truncate(value: number, decimals: number): number {
-  return Number.parseFloat(value.toFixed(decimals))
-}
-
-/**
- * True modulo operation (handles negative numbers correctly).
- *
- * JavaScript's % operator is remainder, not modulo.
- * This function returns a value in [0, d) for positive divisors.
- *
- * @param n - Dividend
- * @param d - Divisor (must be positive)
- * @returns The modulo result
- *
- * @example
- * ```ts
- * // JavaScript remainder vs true modulo
- * -1 % 3        // -1 (remainder)
- * modulo(-1, 3) // 2  (modulo)
- *
- * // Useful for wrapping array indices
- * modulo(index - 1, array.length)
- * ```
- */
-export function modulo(n: number, d: number): number {
-  if (d === 0) return n
-  if (d < 0) return Number.NaN
-  return ((n % d) + d) % d
-}
-
-/**
- * Rounds a number to the nearest multiple.
- *
- * @param value - Number to round
- * @param multiple - Multiple to round to
- * @returns The rounded value
- *
- * @example
- * ```ts
- * roundTo(23, 10)  // 20
- * roundTo(27, 10)  // 30
- * roundTo(0.23, 0.1) // 0.2
- * ```
- */
-export function roundTo(value: number, multiple: number): number {
-  return Math.round(value / multiple) * multiple
-}
-
-/**
- * Converts degrees to radians.
- *
- * @param degrees - Angle in degrees
- * @returns Angle in radians
- *
- * @example
- * ```ts
- * degToRad(180) // Math.PI
- * degToRad(90)  // Math.PI / 2
- * ```
- */
-export function degToRad(degrees: number): number {
-  return (degrees * Math.PI) / 180
-}
-
-/**
- * Converts radians to degrees.
- *
- * @param radians - Angle in radians
- * @returns Angle in degrees
- *
- * @example
- * ```ts
- * radToDeg(Math.PI)     // 180
- * radToDeg(Math.PI / 2) // 90
- * ```
- */
-export function radToDeg(radians: number): number {
-  return (radians * 180) / Math.PI
-}
-
-/**
- * Calculates the distance between two 2D points.
- *
- * @param x1 - First point X
- * @param y1 - First point Y
- * @param x2 - Second point X
- * @param y2 - Second point Y
- * @returns The distance
- *
- * @example
- * ```ts
- * distance(0, 0, 3, 4) // 5
- * ```
- */
-export function distance(
-  x1: number,
-  y1: number,
-  x2: number,
-  y2: number
-): number {
-  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
-}
-
-/**
- * Normalizes a value to a 0-1 range.
- *
- * @param min - Range minimum
- * @param max - Range maximum
- * @param value - Value to normalize
- * @returns Normalized value (0-1)
- *
- * @example
- * ```ts
- * normalize(0, 100, 50)  // 0.5
- * normalize(0, 100, 0)   // 0
- * normalize(0, 100, 100) // 1
- * ```
- */
-export function normalize(min: number, max: number, value: number): number {
-  return (value - min) / (max - min)
-}