effect-start 0.18.0 → 0.20.0

package/src/Values.test.ts

@@ -1,263 +0,0 @@
-import * as test from "bun:test"
-import * as Values from "./Values.ts"
-
-test.describe("isPlainObject", () => {
-  test.it("returns true for plain objects", () => {
-    test
-      .expect(Values.isPlainObject({}))
-      .toBe(true)
-
-    test
-      .expect(Values.isPlainObject({ a: 1, b: 2 }))
-      .toBe(true)
-
-    test
-      .expect(Values.isPlainObject({ nested: { value: true } }))
-      .toBe(true)
-  })
-
-  test.it("returns false for null", () => {
-    test
-      .expect(Values.isPlainObject(null))
-      .toBe(false)
-  })
-
-  test.it("returns false for primitives", () => {
-    test
-      .expect(Values.isPlainObject("string"))
-      .toBe(false)
-
-    test
-      .expect(Values.isPlainObject(42))
-      .toBe(false)
-
-    test
-      .expect(Values.isPlainObject(true))
-      .toBe(false)
-
-    test
-      .expect(Values.isPlainObject(undefined))
-      .toBe(false)
-  })
-
-  test.it("returns false for ArrayBuffer", () => {
-    test
-      .expect(Values.isPlainObject(new ArrayBuffer(8)))
-      .toBe(false)
-  })
-
-  test.it("returns false for ArrayBufferView (Uint8Array)", () => {
-    test
-      .expect(Values.isPlainObject(new Uint8Array([1, 2, 3])))
-      .toBe(false)
-  })
-
-  test.it("returns false for Blob", () => {
-    test
-      .expect(Values.isPlainObject(new Blob(["test"])))
-      .toBe(false)
-  })
-
-  test.it("returns false for FormData", () => {
-    test
-      .expect(Values.isPlainObject(new FormData()))
-      .toBe(false)
-  })
-
-  test.it("returns false for URLSearchParams", () => {
-    test
-      .expect(Values.isPlainObject(new URLSearchParams()))
-      .toBe(false)
-  })
-
-  test.it("returns false for ReadableStream", () => {
-    test
-      .expect(Values.isPlainObject(new ReadableStream()))
-      .toBe(false)
-  })
-
-  test.it("returns false for arrays", () => {
-    test
-      .expect(Values.isPlainObject([]))
-      .toBe(false)
-
-    test
-      .expect(Values.isPlainObject([1, 2, 3]))
-      .toBe(false)
-  })
-
-  test.it("returns false for functions", () => {
-    test
-      .expect(Values.isPlainObject(() => {}))
-      .toBe(false)
-
-    test
-      .expect(Values.isPlainObject(function() {}))
-      .toBe(false)
-  })
-
-  test.it("returns false for class instances", () => {
-    class MyClass {
-      value = 42
-    }
-
-    test
-      .expect(Values.isPlainObject(new MyClass()))
-      .toBe(false)
-  })
-
-  test.it("returns false for Date", () => {
-    test
-      .expect(Values.isPlainObject(new Date()))
-      .toBe(false)
-  })
-
-  test.it("returns false for Map", () => {
-    test
-      .expect(Values.isPlainObject(new Map()))
-      .toBe(false)
-  })
-
-  test.it("returns false for Set", () => {
-    test
-      .expect(Values.isPlainObject(new Set()))
-      .toBe(false)
-  })
-
-  test.it("returns false for RegExp", () => {
-    test
-      .expect(Values.isPlainObject(/test/))
-      .toBe(false)
-  })
-
-  test.it("returns false for Error", () => {
-    test
-      .expect(Values.isPlainObject(new Error("test")))
-      .toBe(false)
-  })
-
-  test.it("returns false for Promise", () => {
-    test
-      .expect(Values.isPlainObject(Promise.resolve()))
-      .toBe(false)
-  })
-
-  test.it("returns true for Object.create(null)", () => {
-    test
-      .expect(Values.isPlainObject(Object.create(null)))
-      .toBe(true)
-  })
-})
-
-test.describe("IsPlainObject", () => {
-  test.it("returns true for plain objects", () => {
-    test
-      .expectTypeOf<Values.IsPlainObject<{ a: number }>>()
-      .toEqualTypeOf<true>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<{ a: number; b: string }>>()
-      .toEqualTypeOf<true>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<{}>>()
-      .toEqualTypeOf<true>()
-  })
-
-  test.it("returns false for functions", () => {
-    test
-      .expectTypeOf<Values.IsPlainObject<() => void>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<(a: number) => string>>()
-      .toEqualTypeOf<false>()
-  })
-
-  test.it("returns false for built-in classes", () => {
-    test
-      .expectTypeOf<Values.IsPlainObject<Request>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<Response>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<Date>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<Map<string, number>>>()
-      .toEqualTypeOf<false>()
-  })
-
-  test.it("returns false for primitives", () => {
-    test
-      .expectTypeOf<Values.IsPlainObject<string>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<number>>()
-      .toEqualTypeOf<false>()
-
-    test
-      .expectTypeOf<Values.IsPlainObject<boolean>>()
-      .toEqualTypeOf<false>()
-  })
-})
-
-test.describe("Simplify", () => {
-  test.it("expands nested plain objects", () => {
-    type Input = {
-      readonly a: { readonly x: number }
-      readonly b: string
-    }
-
-    test
-      .expectTypeOf<Values.Simplify<Input>>()
-      .toEqualTypeOf<{
-        a: { x: number }
-        b: string
-      }>()
-  })
-
-  test.it("preserves Request type", () => {
-    type Input = {
-      request: Request
-      data: { value: number }
-    }
-
-    type Result = Values.Simplify<Input>
-
-    test
-      .expectTypeOf<Result["request"]>()
-      .toEqualTypeOf<Request>()
-
-    test
-      .expectTypeOf<Result["data"]>()
-      .toEqualTypeOf<{ value: number }>()
-  })
-
-  test.it("preserves other built-in types", () => {
-    type Input = {
-      date: Date
-      map: Map<string, number>
-      response: Response
-    }
-
-    type Result = Values.Simplify<Input>
-
-    test
-      .expectTypeOf<Result["date"]>()
-      .toEqualTypeOf<Date>()
-
-    test
-      .expectTypeOf<Result["map"]>()
-      .toEqualTypeOf<Map<string, number>>()
-
-    test
-      .expectTypeOf<Result["response"]>()
-      .toEqualTypeOf<Response>()
-  })
-})

package/src/bun/BunBundle.test.ts

@@ -1,268 +0,0 @@
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as NFS from "node:fs/promises"
-import * as NOS from "node:os"
-import * as NPath from "node:path"
-import * as Bundle from "../bundler/Bundle.ts"
-import * as BundleHttp from "../bundler/BundleHttp.ts"
-import * as TestHttpClient from "../testing/TestHttpClient.ts"
-import * as BunBundle from "./BunBundle.ts"
-
-test.describe("BunBundle manifest structure", () => {
-  test.it("should generate manifest with inputs and outputs arrays", async () => {
-    const tmpDir = await NFS.mkdtemp(
-      NPath.join(NOS.tmpdir(), "effect-start-test-"),
-    )
-
-    try {
-      const htmlContent = `<!DOCTYPE html>
-<html>
-<head><title>Test</title></head>
-<body>
-  <div id="app"></div>
-  <script src="./index.ts" type="module"></script>
-</body>
-</html>`
-
-      const jsContent = `console.log("Hello from test bundle");
-export const greeting = "Hello World";`
-
-      const htmlPath = NPath.join(tmpDir, "index.html")
-      const jsPath = NPath.join(tmpDir, "index.ts")
-
-      await NFS.writeFile(htmlPath, htmlContent)
-      await NFS.writeFile(jsPath, jsContent)
-
-      const bundle = await Effect.runPromise(
-        BunBundle.buildClient({
-          entrypoints: [htmlPath],
-        }),
-      )
-
-      test
-        .expect(bundle.entrypoints)
-        .toBeObject()
-      test
-        .expect(bundle.artifacts)
-        .toBeArray()
-      test
-        .expect(Object.keys(bundle.entrypoints).length)
-        .toBe(1)
-      test
-        .expect(bundle.artifacts.length)
-        .toBe(3)
-
-      const entrypointKeys = Object.keys(bundle.entrypoints)
-      const firstEntrypoint = entrypointKeys[0]
-
-      test
-        .expect(firstEntrypoint)
-        .toBeString()
-      test
-        .expect(bundle.entrypoints[firstEntrypoint])
-        .toBeString()
-
-      const firstArtifact = bundle.artifacts[0]
-
-      test
-        .expect(firstArtifact)
-        .toHaveProperty("path")
-      test
-        .expect(firstArtifact)
-        .toHaveProperty("type")
-      test
-        .expect(firstArtifact)
-        .toHaveProperty("size")
-      test
-        .expect(firstArtifact.size)
-        .toBeGreaterThan(0)
-    } finally {
-      await NFS.rm(tmpDir, {
-        recursive: true,
-        force: true,
-      })
-    }
-  })
-
-  test.it("should serve manifest via HTTP with correct structure", async () => {
-    const tmpDir = await NFS.mkdtemp(
-      NPath.join(NOS.tmpdir(), "effect-start-test-"),
-    )
-
-    try {
-      const htmlContent = `<!DOCTYPE html>
-<html>
-<head><title>Test App</title></head>
-<body><h1>Test</h1></body>
-</html>`
-
-      const htmlPath = NPath.join(tmpDir, "app.html")
-
-      await NFS.writeFile(htmlPath, htmlContent)
-
-      const testLayer = Layer.effect(
-        Bundle.ClientBundle,
-        BunBundle.buildClient({
-          entrypoints: [htmlPath],
-        }),
-      )
-
-      const result = await Effect.runPromise(
-        Effect
-          .scoped(
-            Effect.gen(function*() {
-              const App = HttpRouter.empty.pipe(
-                HttpRouter.mountApp(
-                  "/_bundle",
-                  BundleHttp.httpApp(),
-                ),
-              )
-
-              const Client = TestHttpClient.make(App)
-
-              const response = yield* Client.get("/_bundle/manifest.json")
-
-              const manifestText = yield* response.text
-
-              return JSON.parse(manifestText)
-            }),
-          )
-          .pipe(
-            Effect.provide(testLayer),
-          ),
-      )
-
-      test
-        .expect(result)
-        .toHaveProperty("entrypoints")
-      test
-        .expect(result)
-        .toHaveProperty("artifacts")
-      test
-        .expect(result.entrypoints)
-        .toBeObject()
-      test
-        .expect(result.artifacts)
-        .toBeArray()
-      test
-        .expect(Object.keys(result.entrypoints).length)
-        .toBe(1)
-      test
-        .expect(result.artifacts.length)
-        .toBe(3)
-
-      const entrypointKeys = Object.keys(result.entrypoints)
-      const firstKey = entrypointKeys[0]
-
-      test
-        .expect(firstKey)
-        .toBeString()
-      test
-        .expect(result.entrypoints[firstKey])
-        .toBeString()
-
-      const artifact = result.artifacts[0]
-
-      test
-        .expect(artifact)
-        .toHaveProperty("path")
-      test
-        .expect(artifact)
-        .toHaveProperty("type")
-      test
-        .expect(artifact)
-        .toHaveProperty("size")
-    } finally {
-      await NFS.rm(tmpDir, {
-        recursive: true,
-        force: true,
-      })
-    }
-  })
-
-  test.it("should resolve entrypoints to artifacts correctly", async () => {
-    const tmpDir = await NFS.mkdtemp(
-      NPath.join(NOS.tmpdir(), "effect-start-test-"),
-    )
-
-    try {
-      const htmlContent = `<!DOCTYPE html>
-<html><body>Test</body></html>`
-
-      const htmlPath = NPath.join(tmpDir, "test.html")
-
-      await NFS.writeFile(htmlPath, htmlContent)
-
-      const bundle = await Effect.runPromise(
-        BunBundle.buildClient({
-          entrypoints: [htmlPath],
-        }),
-      )
-
-      const entrypointKeys = Object.keys(bundle.entrypoints)
-      const firstEntrypoint = entrypointKeys[0]
-      const expectedOutput = bundle.entrypoints[firstEntrypoint]
-      const resolvedOutput = bundle.resolve(firstEntrypoint)
-
-      test
-        .expect(resolvedOutput)
-        .toBe(expectedOutput)
-
-      const artifact = bundle.getArtifact(resolvedOutput!)
-
-      test
-        .expect(artifact)
-        .not
-        .toBeNull()
-      test
-        .expect(artifact)
-        .toBeTruthy()
-    } finally {
-      await NFS.rm(tmpDir, {
-        recursive: true,
-        force: true,
-      })
-    }
-  })
-
-  test.it("should include all artifact metadata", async () => {
-    const tmpDir = await NFS.mkdtemp(
-      NPath.join(NOS.tmpdir(), "effect-start-test-"),
-    )
-
-    try {
-      const jsContent = `export const value = 42;`
-      const jsPath = NPath.join(tmpDir, "module.ts")
-
-      await NFS.writeFile(jsPath, jsContent)
-
-      const bundle = await Effect.runPromise(
-        BunBundle.buildClient({
-          entrypoints: [jsPath],
-        }),
-      )
-
-      const artifact = bundle.artifacts[0]
-
-      test
-        .expect(artifact.path)
-        .toBeString()
-      test
-        .expect(artifact.type)
-        .toBeString()
-      test
-        .expect(artifact.size)
-        .toBeNumber()
-      test
-        .expect(artifact.type)
-        .toContain("javascript")
-    } finally {
-      await NFS.rm(tmpDir, {
-        recursive: true,
-        force: true,
-      })
-    }
-  })
-})

package/src/bun/BunBundle_imports.test.ts

@@ -1,48 +0,0 @@
-import * as test from "bun:test"
-import { effectFn } from "../testing"
-import * as BunBundle from "./BunBundle.ts"
-import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
-
-const effect = effectFn()
-
-test.it("imports", () =>
-  effect(function*() {
-    const importTracker = BunImportTrackerPlugin.make()
-    yield* BunBundle.build({
-      target: "bun",
-      plugins: [
-        importTracker,
-      ],
-      entrypoints: [
-        Bun.fileURLToPath(import.meta.resolve("./BunBundle_imports.test.ts")),
-      ],
-    })
-
-    const [
-      e0,
-    ] = importTracker.state.entries()
-
-    test
-      .expect(e0)
-      .toEqual([
-        "src/bun/BunBundle_imports.test.ts",
-        [
-          {
-            kind: "import-statement",
-            path: "bun:test",
-          },
-          {
-            kind: "import-statement",
-            path: "src/testing",
-          },
-          {
-            kind: "import-statement",
-            path: "src/bun/BunBundle.ts",
-          },
-          {
-            kind: "import-statement",
-            path: "src/bun/BunImportTrackerPlugin.ts",
-          },
-        ],
-      ])
-  }))