bsmnt 0.1.0 → 0.1.2

package/packages/create-basement-app/templates/webgpu/lib/utils/math.test.ts

@@ -1,221 +0,0 @@
-/**
- * Unit tests for math utilities
- *
- * Run with: bun test lib/utils/math.test.ts
- */
-
-import { describe, expect, it } from "bun:test"
-import {
-  clamp,
-  degToRad,
-  distance,
-  lerp,
-  mapRange,
-  modulo,
-  normalize,
-  radToDeg,
-  roundTo,
-  truncate,
-} from "./math"
-
-describe("clamp", () => {
-  it("should return input when within bounds", () => {
-    expect(clamp(0, 50, 100)).toBe(50)
-    expect(clamp(-10, 0, 10)).toBe(0)
-  })
-
-  it("should return min when input is below min", () => {
-    expect(clamp(0, -5, 100)).toBe(0)
-    expect(clamp(10, 5, 20)).toBe(10)
-  })
-
-  it("should return max when input is above max", () => {
-    expect(clamp(0, 150, 100)).toBe(100)
-    expect(clamp(10, 25, 20)).toBe(20)
-  })
-
-  it("should handle edge cases", () => {
-    expect(clamp(0, 0, 100)).toBe(0)
-    expect(clamp(0, 100, 100)).toBe(100)
-  })
-})
-
-describe("lerp", () => {
-  it("should return start when amount is 0", () => {
-    expect(lerp(0, 100, 0)).toBe(0)
-    expect(lerp(-50, 50, 0)).toBe(-50)
-  })
-
-  it("should return end when amount is 1", () => {
-    expect(lerp(0, 100, 1)).toBe(100)
-    expect(lerp(-50, 50, 1)).toBe(50)
-  })
-
-  it("should return midpoint when amount is 0.5", () => {
-    expect(lerp(0, 100, 0.5)).toBe(50)
-    expect(lerp(-100, 100, 0.5)).toBe(0)
-  })
-
-  it("should handle intermediate values", () => {
-    expect(lerp(0, 100, 0.25)).toBe(25)
-    expect(lerp(0, 100, 0.75)).toBe(75)
-  })
-
-  it("should extrapolate beyond 0-1 range", () => {
-    expect(lerp(0, 100, 1.5)).toBe(150)
-    expect(lerp(0, 100, -0.5)).toBe(-50)
-  })
-})
-
-describe("mapRange", () => {
-  it("should map value from one range to another", () => {
-    expect(mapRange(0, 100, 50, 0, 1)).toBe(0.5)
-    expect(mapRange(0, 1000, 500, 0, 1)).toBe(0.5)
-  })
-
-  it("should handle inverted output ranges", () => {
-    expect(mapRange(0, 100, 50, 1, 0)).toBe(0.5)
-    expect(mapRange(0, 100, 0, 1, 0)).toBe(1)
-    expect(mapRange(0, 100, 100, 1, 0)).toBe(0)
-  })
-
-  it("should not clamp by default", () => {
-    expect(mapRange(0, 100, 150, 0, 1)).toBe(1.5)
-    expect(mapRange(0, 100, -50, 0, 1)).toBe(-0.5)
-  })
-
-  it("should clamp when shouldClamp is true", () => {
-    expect(mapRange(0, 100, 150, 0, 1, true)).toBe(1)
-    expect(mapRange(0, 100, -50, 0, 1, true)).toBe(0)
-  })
-
-  it("should clamp inverted ranges correctly", () => {
-    expect(mapRange(0, 100, 150, 1, 0, true)).toBe(0)
-    expect(mapRange(0, 100, -50, 1, 0, true)).toBe(1)
-  })
-})
-
-describe("truncate", () => {
-  it("should truncate to specified decimal places", () => {
-    expect(truncate(1.23456789, 2)).toBe(1.23)
-    expect(truncate(1.23456789, 3)).toBe(1.235)
-    expect(truncate(1.23456789, 4)).toBe(1.2346)
-  })
-
-  it("should handle 0 decimal places", () => {
-    expect(truncate(1.23456789, 0)).toBe(1)
-    expect(truncate(3.9, 0)).toBe(4)
-  })
-
-  it("should handle already truncated numbers", () => {
-    expect(truncate(3.14, 2)).toBe(3.14)
-    expect(truncate(5, 2)).toBe(5)
-  })
-})
-
-describe("modulo", () => {
-  it("should work like JavaScript % for positive numbers", () => {
-    expect(modulo(5, 3)).toBe(2)
-    expect(modulo(10, 4)).toBe(2)
-  })
-
-  it("should handle negative dividends correctly (true modulo)", () => {
-    expect(modulo(-1, 3)).toBe(2)
-    expect(modulo(-5, 3)).toBe(1)
-    expect(modulo(-10, 4)).toBe(2)
-  })
-
-  it("should return input when divisor is 0", () => {
-    expect(modulo(5, 0)).toBe(5)
-    expect(modulo(-5, 0)).toBe(-5)
-  })
-
-  it("should return NaN for negative divisors", () => {
-    expect(modulo(5, -3)).toBeNaN()
-  })
-
-  it("should wrap array indices correctly", () => {
-    const length = 5
-    expect(modulo(-1, length)).toBe(4)
-    expect(modulo(5, length)).toBe(0)
-    expect(modulo(7, length)).toBe(2)
-  })
-})
-
-describe("roundTo", () => {
-  it("should round to the nearest multiple", () => {
-    expect(roundTo(23, 10)).toBe(20)
-    expect(roundTo(27, 10)).toBe(30)
-    expect(roundTo(25, 10)).toBe(30)
-  })
-
-  it("should handle decimal multiples", () => {
-    expect(roundTo(0.23, 0.1)).toBeCloseTo(0.2, 10)
-    expect(roundTo(0.27, 0.1)).toBeCloseTo(0.3, 10)
-  })
-
-  it("should handle exact multiples", () => {
-    expect(roundTo(20, 10)).toBe(20)
-    expect(roundTo(0.5, 0.5)).toBe(0.5)
-  })
-})
-
-describe("degToRad", () => {
-  it("should convert degrees to radians", () => {
-    expect(degToRad(0)).toBe(0)
-    expect(degToRad(180)).toBeCloseTo(Math.PI, 10)
-    expect(degToRad(90)).toBeCloseTo(Math.PI / 2, 10)
-    expect(degToRad(360)).toBeCloseTo(Math.PI * 2, 10)
-  })
-
-  it("should handle negative degrees", () => {
-    expect(degToRad(-90)).toBeCloseTo(-Math.PI / 2, 10)
-  })
-})
-
-describe("radToDeg", () => {
-  it("should convert radians to degrees", () => {
-    expect(radToDeg(0)).toBe(0)
-    expect(radToDeg(Math.PI)).toBeCloseTo(180, 10)
-    expect(radToDeg(Math.PI / 2)).toBeCloseTo(90, 10)
-    expect(radToDeg(Math.PI * 2)).toBeCloseTo(360, 10)
-  })
-
-  it("should handle negative radians", () => {
-    expect(radToDeg(-Math.PI / 2)).toBeCloseTo(-90, 10)
-  })
-})
-
-describe("distance", () => {
-  it("should calculate distance between two points", () => {
-    expect(distance(0, 0, 3, 4)).toBe(5)
-    expect(distance(0, 0, 0, 0)).toBe(0)
-  })
-
-  it("should handle negative coordinates", () => {
-    expect(distance(-3, -4, 0, 0)).toBe(5)
-    expect(distance(-1, -1, 1, 1)).toBeCloseTo(Math.sqrt(8), 10)
-  })
-
-  it("should be symmetric", () => {
-    expect(distance(0, 0, 3, 4)).toBe(distance(3, 4, 0, 0))
-  })
-})
-
-describe("normalize", () => {
-  it("should normalize value to 0-1 range", () => {
-    expect(normalize(0, 100, 50)).toBe(0.5)
-    expect(normalize(0, 100, 0)).toBe(0)
-    expect(normalize(0, 100, 100)).toBe(1)
-  })
-
-  it("should handle non-zero min values", () => {
-    expect(normalize(50, 100, 75)).toBe(0.5)
-    expect(normalize(-100, 100, 0)).toBe(0.5)
-  })
-
-  it("should extrapolate outside range", () => {
-    expect(normalize(0, 100, 150)).toBe(1.5)
-    expect(normalize(0, 100, -50)).toBe(-0.5)
-  })
-})

package/packages/create-basement-app/templates/webgpu/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)
-}

package/packages/create-basement-app/templates/webgpu/lib/utils/metadata.ts

@@ -1,126 +0,0 @@
-import type { Metadata } from "next"
-
-/**
- * Metadata Generation Utilities
- *
- * Helpers to generate consistent metadata across pages,
- * reducing duplication and ensuring SEO best practices.
- */
-
-interface GenerateMetadataOptions {
-  title?: string
-  description?: string
-  keywords?: string[]
-  image?: {
-    url?: string
-    width?: number
-    height?: number
-    alt?: string
-  }
-  url?: string
-  siteName?: string
-  noIndex?: boolean
-  type?: "website" | "article"
-  publishedTime?: string
-  modifiedTime?: string
-  authors?: string[]
-}
-
-const APP_BASE_URL =
-  process.env.NEXT_PUBLIC_BASE_URL ?? "https://localhost:3000"
-
-/**
- * Generate complete metadata object for pages
- *
- * @example
- * ```ts
- * export async function generateMetadata({ params }) {
- *   const page = await fetchPage(params.slug)
- *
- *   return generatePageMetadata({
- *     title: page.metadata?.title || page.title,
- *     description: page.metadata?.description,
- *     image: { url: page.metadata?.image?.asset?.url },
- *     url: `/page/${params.slug}`,
- *     noIndex: page.metadata?.noIndex,
- *   })
- * }
- * ```
- */
-export function generatePageMetadata(
-  options: GenerateMetadataOptions
-): Metadata {
-  const {
-    title,
-    description,
-    keywords,
-    image,
-    url,
-    siteName = "Satūs",
-    noIndex = false,
-    type = "website",
-    publishedTime,
-    modifiedTime,
-    authors,
-  } = options
-
-  const fullUrl = url ? `${APP_BASE_URL}${url}` : APP_BASE_URL
-  const imageUrl = image?.url || "/opengraph-image.jpg"
-  const imageWidth = image?.width || 1200
-  const imageHeight = image?.height || 630
-  const imageAlt = image?.alt || title || siteName
-
-  const metadata: Metadata = {
-    metadataBase: new URL(APP_BASE_URL),
-    title,
-    description,
-    keywords,
-    alternates: {
-      canonical: url || "/",
-    },
-    openGraph: {
-      title,
-      description,
-      url: fullUrl,
-      siteName,
-      locale: "en_US",
-      type,
-      images: [
-        {
-          url: imageUrl,
-          width: imageWidth,
-          height: imageHeight,
-          alt: imageAlt,
-        },
-      ],
-      ...(publishedTime && { publishedTime }),
-      ...(modifiedTime && { modifiedTime }),
-      ...(authors && { authors }),
-    },
-    twitter: {
-      card: "summary_large_image",
-      title,
-      description,
-      images: [
-        {
-          url: imageUrl,
-          width: imageWidth,
-          height: imageHeight,
-          alt: imageAlt,
-        },
-      ],
-    },
-    other: {
-      "fb:app_id": process.env.NEXT_PUBLIC_FACEBOOK_APP_ID || "",
-    },
-  }
-
-  if (noIndex) {
-    metadata.robots = {
-      index: false,
-      follow: false,
-    }
-  }
-
-  return metadata
-}