effect-start 0.21.0 → 0.22.0

package/src/TuplePathPattern.ts

@@ -1,64 +1,75 @@
-export type PathTuple = ReadonlyArray<
-  string | [string, string?, string?] | [[string]]
->
+export type PathTuple = ReadonlyArray<string | [string, string?, string?] | [[string]]>
 
 export function format(tuple: PathTuple): `/${string}` {
-  return "/" + tuple
-    .map((el) => {
-      if (typeof el === "string") return el
-      if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
-      const [name, suffix, prefix] = el
-      return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
-    })
-    .join("/") as `/${string}`
+  return ("/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
+      })
+      .join("/")) as `/${string}`
 }
 
 export function toColon(tuple: PathTuple): string {
-  return "/" + tuple
-    .map((el) => {
-      if (typeof el === "string") return el
-      if (Array.isArray(el[0])) return "*"
-      const [name, suffix, prefix] = el
-      return (prefix ?? "") + ":" + name + (suffix ?? "")
-    })
-    .join("/")
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "*"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
 
 export const toHono = toColon
 
 export function toExpress(tuple: PathTuple): string {
-  return "/" + tuple
-    .map((el) => {
-      if (typeof el === "string") return el
-      if (Array.isArray(el[0])) return "*" + el[0][0]
-      const [name, suffix, prefix] = el
-      return (prefix ?? "") + ":" + name + (suffix ?? "")
-    })
-    .join("/")
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "*" + el[0][0]
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
 
 export const toEffect = toColon
 
 export function toURLPattern(tuple: PathTuple): string {
-  return "/" + tuple
-    .map((el) => {
-      if (typeof el === "string") return el
-      if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
-      const [name, suffix, prefix] = el
-      return (prefix ?? "") + ":" + name + (suffix ?? "")
-    })
-    .join("/")
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
 
 export function toRemix(tuple: PathTuple): string {
-  return "/" + tuple
-    .map((el) => {
-      if (typeof el === "string") return el
-      if (Array.isArray(el[0])) return "$"
-      const [name, suffix, prefix] = el
-      return (prefix ?? "") + "$" + name + (suffix ?? "")
-    })
-    .join("/")
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "$"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + "$" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
 
 export const toBun = toColon

package/src/Unique.ts

@@ -66,12 +66,12 @@ export function toTimestamp(bytes: Uint8Array): number {
   if (bytes.length < 6) return 0
 
   return (
-    bytes[0] * 0x10000000000
-    + bytes[1] * 0x100000000
-    + bytes[2] * 0x1000000
-    + bytes[3] * 0x10000
-    + bytes[4] * 0x100
-    + bytes[5]
+    bytes[0] * 0x10000000000 +
+    bytes[1] * 0x100000000 +
+    bytes[2] * 0x1000000 +
+    bytes[3] * 0x10000 +
+    bytes[4] * 0x100 +
+    bytes[5]
   )
 }
 
@@ -153,7 +153,7 @@ function formatUlid(bytes: Uint8Array): string {
 
 function encodeUlidTime(time: number): string {
   let value = BigInt(time)
-  const result = new Array<string>(10)
+  const result = Array.from<string>({ length: 10 })
 
   for (let i = 9; i >= 0; i--) {
     result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)]
@@ -178,10 +178,7 @@ function toSafeTime(time: number): number {
  * It's qt lil opt from the times where web developers
  * were competing to have the smallest possible bundle size.
  */
-export function nanoid(
-  size = 21,
-  alphabet = ALPHABET_BASE64_URL,
-): string {
+export function nanoid(size = 21, alphabet = ALPHABET_BASE64_URL): string {
   if (size <= 0 || alphabet.length === 0) return ""
 
   const length = alphabet.length
@@ -201,10 +198,7 @@ export function nanoid(
   return id
 }
 
-function toBase32(
-  bytes: Uint8Array,
-  alphabet = ALPHABET_BASE32_CROCKFORD,
-): string {
+function toBase32(bytes: Uint8Array, alphabet = ALPHABET_BASE32_CROCKFORD): string {
   if (bytes.length === 0) return ""
 
   let result = ""

package/src/Values.ts

@@ -1,8 +1,4 @@
-type JsonPrimitives =
-  | string
-  | number
-  | boolean
-  | null
+type JsonPrimitives = string | number | boolean | null
 
 export type JsonObject = {
   [key: string]:
@@ -12,33 +8,28 @@ export type JsonObject = {
     | undefined
 }
 
-export type Json =
-  | JsonPrimitives
-  | Json[]
-  | JsonObject
+export type Json = JsonPrimitives | Json[] | JsonObject
 
-export function isPlainObject(
-  value: unknown,
-): value is Record<string, unknown> {
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== "object") {
     return false
   }
 
   // Check for built-in types and web APIs
   if (
-    ArrayBuffer.isView(value)
-    || value instanceof ArrayBuffer
-    || value instanceof Blob
-    || value instanceof FormData
-    || value instanceof URLSearchParams
-    || value instanceof ReadableStream
-    || value instanceof Date
-    || value instanceof Map
-    || value instanceof Set
-    || value instanceof RegExp
-    || value instanceof Error
-    || value instanceof Promise
-    || Array.isArray(value)
+    ArrayBuffer.isView(value) ||
+    value instanceof ArrayBuffer ||
+    value instanceof Blob ||
+    value instanceof FormData ||
+    value instanceof URLSearchParams ||
+    value instanceof ReadableStream ||
+    value instanceof Date ||
+    value instanceof Map ||
+    value instanceof Set ||
+    value instanceof RegExp ||
+    value instanceof Error ||
+    value instanceof Promise ||
+    Array.isArray(value)
   ) {
     return false
   }
@@ -56,19 +47,24 @@ export function isPlainObject(
  * class instances or objects with methods.
  */
 type HasMethod<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? true : never
+  [K in keyof T]: T[K] extends (...args: Array<any>) => any ? true : never
 }[keyof T]
 
-export type IsPlainObject<T> = T extends object ? T extends Function ? false
-  : HasMethod<T> extends never ? true
-  : false
+export type IsPlainObject<T> = T extends object
+  ? T extends Function
+    ? false
+    : HasMethod<T> extends never
+      ? true
+      : false
   : false
 
 export type Simplify<T> = {
   -readonly [K in keyof T]: IsPlainObject<T[K]> extends true
     ? { -readonly [P in keyof T[K]]: T[K][P] }
     : T[K]
-} extends infer U ? { [K in keyof U]: U[K] } : never
+} extends infer U
+  ? { [K in keyof U]: U[K] }
+  : never
 
 export const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array => {
   const result = new Uint8Array(a.byteLength + b.byteLength)

package/src/bun/BunBundle.ts

@@ -1,32 +1,12 @@
-import type {
-  BuildConfig,
-  BuildOutput,
-} from "bun"
-import {
-  Array,
-  Context,
-  Effect,
-  Iterable,
-  Layer,
-  pipe,
-  Record,
-} from "effect"
+import type { BuildConfig, BuildOutput } from "bun"
+import { Array, type Context, Effect, Iterable, Layer, pipe, Record } from "effect"
 import * as NPath from "node:path"
-import type {
-  BundleContext,
-  BundleManifest,
-} from "../bundler/Bundle.ts"
 import * as Bundle from "../bundler/Bundle.ts"
-import { BunImportTrackerPlugin } from "./index.ts"
+import type { BunImportTrackerPlugin } from "./index.ts"
 
-export type BuildOptions = Omit<
-  BuildConfig,
-  "outdir"
->
+export type BuildOptions = Omit<BuildConfig, "outdir">
 
-export const buildClient = (
-  config: BuildOptions | string,
-) => {
+export const buildClient = (config: BuildOptions | string) => {
   if (typeof config === "string") {
     config = {
       entrypoints: [config],
@@ -52,9 +32,7 @@ export const buildClient = (
   return build(resolvedConfig)
 }
 
-export const buildServer = (
-  config: BuildOptions | string,
-) => {
+export const buildServer = (config: BuildOptions | string) => {
   if (typeof config === "string") {
     config = {
       entrypoints: [config],
@@ -84,26 +62,18 @@ export const buildServer = (
  */
 export function build(
   config: BuildOptions,
-): Effect.Effect<BundleContext, Bundle.BundleError> {
-  return Effect.gen(function*() {
+): Effect.Effect<Bundle.BundleContext, Bundle.BundleError> {
+  return Effect.gen(function* () {
     const output = yield* buildBun(config)
-    const manifest = generateManifestfromBunBundle(
-      config,
-      output,
-    )
-    const artifactsMap = Record.fromIterableBy(
-      output.outputs,
-      (v) => v.path.replace(/^\.\//, ""),
-    )
+    const manifest = generateManifestfromBunBundle(config, output)
+    const artifactsMap = Record.fromIterableBy(output.outputs, (v) => v.path.replace(/^\.\//, ""))
 
     const resolve = (path: string) => {
       return manifest.entrypoints[path] ?? null
     }
 
     const getArtifact = (path: string): Blob | null => {
-      return artifactsMap[resolve(path)]
-        ?? artifactsMap[path]
-        ?? null
+      return artifactsMap[resolve(path)] ?? artifactsMap[path] ?? null
     }
 
     return {
@@ -114,37 +84,31 @@ export function build(
   })
 }
 
-export function layer<T>(
-  tag: Context.Tag<T, BundleContext>,
-  config: BuildOptions,
-) {
+export function layer<T>(tag: Context.Tag<T, Bundle.BundleContext>, config: BuildOptions) {
   return Layer.effect(tag, build(config))
 }
 
 /**
  * Finds common path prefix across provided paths.
  */
-function getBaseDir(paths: string[]) {
+function getBaseDir(paths: Array<string>) {
   if (paths.length === 0) return ""
   if (paths.length === 1) return NPath.dirname(paths[0])
 
-  const segmentsList = paths.map((path) =>
-    NPath.dirname(path).split("/").filter(Boolean)
-  )
+  const segmentsList = paths.map((path) => NPath.dirname(path).split("/").filter(Boolean))
 
-  return segmentsList[0]
-    .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
-    .reduce((path, seg) => `${path}/${seg}`, "") ?? ""
+  return (
+    segmentsList[0]
+      .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
+      .reduce((path, seg) => `${path}/${seg}`, "") ?? ""
+  )
 }
 
 /**
  * Maps entrypoints to their respective build artifacts.
  * Entrypoint key is trimmed to remove common path prefix.
  */
-function joinBuildEntrypoints(
-  options: BuildOptions,
-  output: BuildOutput,
-) {
+function joinBuildEntrypoints(options: BuildOptions, output: BuildOutput) {
   const commonPathPrefix = getBaseDir(options.entrypoints) + "/"
 
   return pipe(
@@ -153,9 +117,8 @@ function joinBuildEntrypoints(
       pipe(
         output.outputs,
         // Filter out source maps to properly map artifacts to entrypoints.
-        Iterable.filter((v) =>
-          v.kind !== "sourcemap"
-          && !(v.loader === "html" && v.path.endsWith(".js"))
+        Iterable.filter(
+          (v) => v.kind !== "sourcemap" && !(v.loader === "html" && v.path.endsWith(".js")),
         ),
       ),
     ),
@@ -177,18 +140,13 @@ function generateManifestfromBunBundle(
   options: BuildOptions,
   output: BuildOutput,
   imports?: BunImportTrackerPlugin.ImportMap,
-): BundleManifest {
+): Bundle.BundleManifest {
   const entrypointArtifacts = joinBuildEntrypoints(options, output)
 
   return {
     entrypoints: pipe(
       entrypointArtifacts,
-      Iterable.map((v) =>
-        [
-          v.shortPath,
-          v.artifact.path.replace(/^\.\//, ""),
-        ] as const
-      ),
+      Iterable.map((v) => [v.shortPath, v.artifact.path.replace(/^\.\//, "")] as const),
       Record.fromEntries,
     ),
 
@@ -211,17 +169,13 @@ function generateManifestfromBunBundle(
   }
 }
 
-function buildBun(
-  config: BuildOptions,
-): Effect.Effect<BuildOutput, Bundle.BundleError, never> {
+function buildBun(config: BuildOptions): Effect.Effect<BuildOutput, Bundle.BundleError, never> {
   return Object.assign(
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const buildOutput: BuildOutput = yield* Effect.tryPromise({
         try: () => Bun.build(config),
         catch: (err: AggregateError | unknown) => {
-          const cause = err instanceof AggregateError
-            ? err.errors?.[0] ?? err
-            : err
+          const cause = err instanceof AggregateError ? (err.errors?.[0] ?? err) : err
 
           return new Bundle.BundleError({
             message: "Failed to Bun.build: " + cause,

package/src/bun/BunImportTrackerPlugin.ts

@@ -1,23 +1,22 @@
-import {
-  type BunPlugin,
-  type Import,
-} from "bun"
+import { type BunPlugin, type Import } from "bun"
 import * as NPath from "node:path"
 
-export type ImportMap = ReadonlyMap<string, Import[]>
+export type ImportMap = ReadonlyMap<string, Array<Import>>
 
 /**
  * Tracks all imported modules.
  * State can be accessed via 'virtual:import-tracker' module within a bundle
  * or through `state` property returned by this function.
  */
-export const make = (opts: {
-  includeNodeModules?: false
-  baseDir?: string
-} = {}): BunPlugin & {
+export const make = (
+  opts: {
+    includeNodeModules?: false
+    baseDir?: string
+  } = {},
+): BunPlugin & {
   state: ImportMap
 } => {
-  const foundImports: Map<string, Import[]> = new Map()
+  const foundImports: Map<string, Array<Import>> = new Map()
   const baseDir = opts.baseDir ?? process.cwd()
 
   return {
@@ -29,67 +28,70 @@ export const make = (opts: {
 
       // Each module that goes through this onLoad callback
       // will record its imports in `trackedImports`
-      build.onLoad({
-        filter: /\.(ts|js)x?$/,
-      }, async (args) => {
-        if (
-          !opts.includeNodeModules
-          && args.path.includes("/node_modules/")
-        ) {
-          return undefined
-        }
+      build.onLoad(
+        {
+          filter: /\.(ts|js)x?$/,
+        },
+        async (args) => {
+          if (!opts.includeNodeModules && args.path.includes("/node_modules/")) {
+            return undefined
+          }
 
-        const contents = await Bun.file(args.path).arrayBuffer()
-        try {
-          const fileImport = transpiler.scanImports(contents)
-          const resolvedImports = fileImport.map(imp => {
-            const absoluteImportPath = NPath.resolve(
-              NPath.dirname(args.path),
-              // 'file' is a default namespace, trim it
-              imp.path.replace(/^file:/, ""),
-            )
+          const contents = await Bun.file(args.path).arrayBuffer()
+          try {
+            const fileImport = transpiler.scanImports(contents)
+            const resolvedImports = fileImport.map((imp) => {
+              const absoluteImportPath = NPath.resolve(
+                NPath.dirname(args.path),
+                // 'file' is a default namespace, trim it
+                imp.path.replace(/^file:/, ""),
+              )
 
-            return {
-              ...imp,
-              // keep all module identifiers with namespace intact
-              path: /(\w+):/.test(imp.path)
-                ? imp.path
-                : NPath.relative(baseDir, absoluteImportPath),
-            }
-          })
-          foundImports.set(NPath.relative(baseDir, args.path), resolvedImports)
-        } catch (e) {
-        }
+              return {
+                ...imp,
+                // keep all module identifiers with namespace intact
+                path: /(\w+):/.test(imp.path)
+                  ? imp.path
+                  : NPath.relative(baseDir, absoluteImportPath),
+              }
+            })
+            foundImports.set(NPath.relative(baseDir, args.path), resolvedImports)
+          } catch (e) {}
 
-        return undefined
-      })
+          return undefined
+        },
+      )
 
-      build.onResolve({
-        filter: /^virtual:import-tracker$/,
-      }, () => {
-        return {
-          namespace: "effect-start",
-          path: "virtual:import-tracker",
-        }
-      })
+      build.onResolve(
+        {
+          filter: /^virtual:import-tracker$/,
+        },
+        () => {
+          return {
+            namespace: "effect-start",
+            path: "virtual:import-tracker",
+          }
+        },
+      )
 
-      build.onLoad({
-        filter: /^virtual:import-tracker$/,
-        namespace: "effect-start",
-      }, async (args) => {
-        // Wait for all files to be loaded, ensuring
-        // that every file goes through the above `onLoad()` function
-        // and their imports tracked
-        await args.defer()
+      build.onLoad(
+        {
+          filter: /^virtual:import-tracker$/,
+          namespace: "effect-start",
+        },
+        async (args) => {
+          // Wait for all files to be loaded, ensuring
+          // that every file goes through the above `onLoad()` function
+          // and their imports tracked
+          await args.defer()
 
-        // Emit JSON containing the stats of each import
-        return {
-          contents: JSON.stringify(
-            Object.fromEntries(foundImports.entries()),
-          ),
-          loader: "json",
-        }
-      })
+          // Emit JSON containing the stats of each import
+          return {
+            contents: JSON.stringify(Object.fromEntries(foundImports.entries())),
+            loader: "json",
+          }
+        },
+      )
     },
 
     state: foundImports,