Merge branch 'denoland:main' into feature/add_ip_restriction_middleware

Author: Octo8080X

deno.json

@@ -1,4 +1,5 @@
 {
+  "vendor": true,
   "nodeModulesDir": "manual",
   "workspace": [
     "./packages/*",

docs/latest/examples/daisyui.md

@@ -14,9 +14,9 @@ To get started with daisyUI, make sure you have Tailwind CSS enabled in your
 Fresh project, then install daisyUI and update your configuration.
 
 1. Run `deno i -D npm:daisyui@latest` to install daisyUI
-2. Add daisyUI configuration in `./static/styles.css`:
+2. Add daisyUI configuration in `./assets/styles.css`:
 
-   ```diff static/styles.css
+   ```diff assets/styles.css
      @import "tailwindcss";
    + @plugin "daisyui";
    ```

packages/examples/src/app1.tsx

@@ -1,6 +1,13 @@
+/**
+ * Module containing a simple example Fresh App
+ *
+ * @module
+ */
+
 import { App } from "fresh";
 import { Doc } from "./shared.tsx";
 
+/** App that renders a sample HTML document */
 export const app1: App<unknown> = new App()
   .get("/", (ctx) =>
     ctx.render(

packages/examples/src/app2.tsx

@@ -1,6 +1,13 @@
+/**
+ * Module containing a simple example Fresh App
+ *
+ * @module
+ */
+
 import { App } from "fresh";
 import { Doc } from "./shared.tsx";
 
+/** App that renders a sample HTML document */
 export const app2: App<unknown> = new App()
   .get("/", (ctx) =>
     ctx.render(

packages/examples/src/island.tsx

@@ -1,6 +1,24 @@
+/**
+ * Example of external Fresh Island component.
+ *
+ * @example
+ * ```tsx
+ * import { App } from "fresh";
+ * import { DemoIsland } from "jsr:@fresh/examples/island";
+ *
+ * const app = new App();
+ *
+ * // Use the island somewhere in your components
+ * app.get("/", (ctx) => ctx.render(<DemoIsland />));
+ * ```
+ *
+ * @module
+ */
+
 import { useSignal } from "@preact/signals";
 import type { JSX } from "preact";
 
+/** A simple counter demo island component using Preact signals */
 export function DemoIsland(): JSX.Element {
   const count = useSignal(0);
 

packages/fresh/README.md

@@ -5,3 +5,27 @@ Standards. It’s designed for building high-quality, performant, and personaliz
 web applications.
 
 [Learn more about Fresh](https://fresh.deno.dev/)
+
+## Usage
+
+Generate a new Fresh project with `@fresh/init`:
+
+```sh
+deno run -Ar jsr:@fresh/init
+```
+
+Add middleware, routes, & endpoints as needed via the `routes/` folder or
+directly on the `App` instance.
+
+```tsx
+import { App } from "fresh";
+
+const app = new App()
+  .get("/", () => new Response("hello world"))
+  .get("/jsx", (ctx) => ctx.render(<h1>render JSX!</h1>));
+
+app.listen();
+```
+
+For more information on getting started with Fresh, head on over to the
+[documentation](https://fresh.deno.dev/docs/introduction).

packages/fresh/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fresh/core",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

packages/fresh/src/app.ts

@@ -154,6 +154,12 @@ export let setBuildCache: <State>(
   cache: BuildCache<State>,
   mode: "development" | "production",
 ) => void;
+export let setErrorInterceptor: <State>(
+  app: App<State>,
+  fn: (err: unknown) => void,
+) => void;
+
+const NOOP = () => {};
 
 /**
  * Create an application instance that passes the incoming `Request`
@@ -162,6 +168,7 @@ export let setBuildCache: <State>(
 export class App<State> {
   #getBuildCache: () => BuildCache<State> | null = () => null;
   #commands: Command<State>[] = [];
+  #onError: (err: unknown) => void = NOOP;
 
   static {
     getBuildCache = (app) => app.#getBuildCache();
@@ -170,6 +177,9 @@ export class App<State> {
       app.config.mode = mode;
       app.#getBuildCache = () => cache;
     };
+    setErrorInterceptor = (app, fn) => {
+      app.#onError = fn;
+    };
   }
 
   /**
@@ -432,7 +442,7 @@ export class App<State> {
       try {
         if (handlers.length === 0) return await next();
 
-        const result = await runMiddlewares(handlers, ctx);
+        const result = await runMiddlewares(handlers, ctx, this.#onError);
         if (!(result instanceof Response)) {
           throw new Error(
             `Expected a "Response" instance to be returned, but got: ${result}`,

packages/fresh/src/context.ts

@@ -28,6 +28,8 @@ import {
 } from "./render.ts";
 import { renderToString } from "preact-render-to-string";
 
+const ENCODER = new TextEncoder();
+
 export interface Island {
   file: string;
   name: string;
@@ -258,11 +260,7 @@ export class Context<State> {
       appVNode = appChild ?? h(Fragment, null);
     }
 
-    const headers = init.headers !== undefined
-      ? init.headers instanceof Headers
-        ? init.headers
-        : new Headers(init.headers)
-      : new Headers();
+    const headers = getHeadersFromInit(init);
 
     headers.set("Content-Type", "text/html; charset=utf-8");
     const responseInit: ResponseInit = {
@@ -376,4 +374,102 @@ export class Context<State> {
     });
     return new Response(html, responseInit);
   }
+
+  /**
+   * Respond with text. Sets `Content-Type: text/plain`.
+   * ```tsx
+   * app.use(ctx => ctx.text("Hello World!"));
+   * ```
+   */
+  text(content: string, init?: ResponseInit): Response {
+    return new Response(content, init);
+  }
+
+  /**
+   * Respond with html string. Sets `Content-Type: text/html`.
+   * ```tsx
+   * app.get("/", ctx => ctx.html("<h1>foo</h1>"));
+   * ```
+   */
+  html(content: string, init?: ResponseInit): Response {
+    const headers = getHeadersFromInit(init);
+    headers.set("Content-Type", "text/html; charset=utf-8");
+
+    return new Response(content, { ...init, headers });
+  }
+
+  /**
+   * Respond with json string, same as `Response.json()`. Sets
+   * `Content-Type: application/json`.
+   * ```tsx
+   * app.get("/", ctx => ctx.json({ foo: 123 }));
+   * ```
+   */
+  // deno-lint-ignore no-explicit-any
+  json(content: any, init?: ResponseInit): Response {
+    return Response.json(content, init);
+  }
+
+  /**
+   * Helper to stream a sync or async iterable and encode text
+   * automatically.
+   *
+   * ```tsx
+   * function* gen() {
+   *   yield "foo";
+   *   yield "bar";
+   * }
+   *
+   * app.use(ctx => ctx.stream(gen()))
+   * ```
+   *
+   * Or pass in the function directly:
+   *
+   * ```tsx
+   * app.use(ctx => {
+   *   return ctx.stream(function* gen() {
+   *     yield "foo";
+   *     yield "bar";
+   *   });
+   * );
+   * ```
+   */
+  stream<U extends string | Uint8Array>(
+    stream:
+      | Iterable<U>
+      | AsyncIterable<U>
+      | (() => Iterable<U> | AsyncIterable<U>),
+    init?: ResponseInit,
+  ): Response {
+    const raw = typeof stream === "function" ? stream() : stream;
+
+    const body = ReadableStream.from(raw)
+      .pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            if (chunk instanceof Uint8Array) {
+              // deno-lint-ignore no-explicit-any
+              controller.enqueue(chunk as any);
+            } else if (chunk === undefined) {
+              controller.enqueue(undefined);
+            } else {
+              const raw = ENCODER.encode(String(chunk));
+              controller.enqueue(raw);
+            }
+          },
+        }),
+      );
+
+    return new Response(body, init);
+  }
+}
+
+function getHeadersFromInit(init?: ResponseInit) {
+  if (init === undefined) {
+    return new Headers();
+  }
+
+  return init.headers !== undefined
+    ? init.headers instanceof Headers ? init.headers : new Headers(init.headers)
+    : new Headers();
 }

packages/fresh/src/context_test.tsx

@@ -106,3 +106,100 @@ Deno.test("ctx.route - should contain matched route", async () => {
   await server.get("/foo/123");
   expect(route).toEqual("/foo/:id");
 });
+
+Deno.test("ctx.text()", async () => {
+  const app = new App()
+    .get("/", (ctx) => ctx.text("foobar"));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+
+  expect(res.headers.get("Content-Type")).toEqual("text/plain;charset=UTF-8");
+  const text = await res.text();
+  expect(text).toEqual("foobar");
+});
+
+Deno.test("ctx.html()", async () => {
+  const app = new App()
+    .get("/", (ctx) => ctx.html("<h1>foo</h1>"));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+
+  expect(res.headers.get("Content-Type")).toEqual("text/html; charset=utf-8");
+  const text = await res.text();
+  expect(text).toEqual("<h1>foo</h1>");
+});
+
+Deno.test("ctx.json()", async () => {
+  const app = new App()
+    .get("/", (ctx) => ctx.json({ foo: 123 }));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+
+  expect(res.headers.get("Content-Type")).toEqual("application/json");
+  const text = await res.text();
+  expect(text).toEqual('{"foo":123}');
+});
+
+Deno.test("ctx.stream() - enqueue values", async () => {
+  function* gen() {
+    yield "foo";
+    yield new TextEncoder().encode("bar");
+  }
+
+  const app = new App()
+    .get("/", (ctx) => ctx.stream(gen()));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+  const text = await res.text();
+  expect(text).toEqual("foobar");
+});
+
+Deno.test("ctx.stream() - pass function", async () => {
+  const app = new App()
+    .get("/", (ctx) =>
+      ctx.stream(function* () {
+        yield "foo";
+        yield "bar";
+      }));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+  const text = await res.text();
+  expect(text).toEqual("foobar");
+});
+
+Deno.test("ctx.stream() - support iterable", async () => {
+  function* gen() {
+    yield "foo";
+    yield "bar";
+  }
+
+  const app = new App()
+    .get("/", (ctx) => ctx.stream(gen()));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+  const text = await res.text();
+
+  expect(text).toEqual("foobar");
+});
+
+Deno.test("ctx.stream() - support async iterable", async () => {
+  async function* gen() {
+    yield "foo";
+    yield "bar";
+  }
+
+  const app = new App()
+    .get("/", (ctx) => ctx.stream(gen()));
+
+  const server = new FakeServer(app.handler());
+  const res = await server.get("/");
+  const text = await res.text();
+
+  expect(text).toEqual("foobar");
+});