@raubjo/architect 0.5.1

package/src/support/num.ts

@@ -0,0 +1,50 @@
+export function format(value: number, precision?: number, locale?: string): string {
+    return new Intl.NumberFormat(locale, {
+        minimumFractionDigits: precision,
+        maximumFractionDigits: precision,
+    }).format(value)
+}
+
+export function percentage(value: number, precision = 0, locale?: string): string {
+    return new Intl.NumberFormat(locale, {
+        style: "percent",
+        minimumFractionDigits: precision,
+        maximumFractionDigits: precision,
+    }).format(value / 100)
+}
+
+export function currency(value: number, currencyCode = "USD", locale?: string): string {
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode,
+    }).format(value)
+}
+
+export function fileSize(bytes: number, precision = 0): string {
+    const units = ["B", "KB", "MB", "GB", "TB"]
+    let size = bytes
+    let unit = 0
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024
+        unit++
+    }
+    return `${size.toFixed(precision)} ${units[unit]}`
+}
+
+export function abbreviate(value: number, precision = 0, locale?: string): string {
+    const abs = Math.abs(value)
+    if (abs >= 1_000_000_000) return `${format(value / 1_000_000_000, precision, locale)}B`
+    if (abs >= 1_000_000) return `${format(value / 1_000_000, precision, locale)}M`
+    if (abs >= 1_000) return `${format(value / 1_000, precision, locale)}K`
+    return format(value, precision, locale)
+}
+
+export function clamp(value: number, min: number, max: number): number {
+    return Math.min(Math.max(value, min), max)
+}
+
+export function between(value: number, min: number, max: number): boolean {
+    return value >= min && value <= max
+}
+
+export const Num = { format, percentage, currency, fileSize, abbreviate, clamp, between }

package/src/support/pipeline.ts

@@ -0,0 +1,29 @@
+type Pipe<T> = (passable: T, next: (passable: T) => T) => T
+
+class PipelineRunner<T> {
+    passable!: T
+    pipes: Pipe<T>[] = []
+
+    through(pipes: Pipe<T>[]): this {
+        this.pipes = [...pipes]
+        return this
+    }
+
+    // biome-ignore lint/suspicious/noThenProperty: this is thenable
+    then(destination: (passable: T) => T): T {
+        const fn = [...this.pipes]
+            .reverse()
+            .reduce<(passable: T) => T>((next, pipe) => (passable) => pipe(passable, next), destination)
+        return fn(this.passable)
+    }
+
+    thenReturn(): T {
+        return this.then((passable) => passable)
+    }
+}
+
+export function send<T>(passable: T): PipelineRunner<T> {
+    const runner = new PipelineRunner<T>()
+    runner.passable = passable
+    return runner
+}

package/src/support/service-provider.ts

@@ -0,0 +1,19 @@
+import type { ContainerContract } from "../container/contract"
+
+export type Cleanup = () => void
+
+export type ServiceProviderContext = {
+    container: ContainerContract
+}
+
+export default class ServiceProvider {
+    register(_context: ServiceProviderContext): void | Cleanup {}
+
+    boot(_context: ServiceProviderContext): void | Cleanup {}
+}
+
+export class DeferrableServiceProvider extends ServiceProvider {
+    provides(): Array<string> {
+        return []
+    }
+}