open-index/open-npm huggingface dataset:
npm package: @hattip/polyfills
Description: Fetch API polyfills
Author: Fatih Aygün
Latest version: 0.0.49

# `@hattip/polyfills`

Fetch API polyfills

- `node-fetch`: [`node-fetch`](https://github.com/node-fetch/node-fetch) as packaged by [node-fetch-native](https://github.com/unjs/node-fetch-native)
- `get-set-cookie`: [`Headers.prototype.getSetCookie`](https://github.com/whatwg/fetch/pull/1346)
- `crypto`: Web Crypto API. Requires Node 16 or later.
- `half-duplex-request`: Temporary fix for [Node.js issue #46221](https://github.com/nodejs/node/issues/46221)
npm package: @hattip/response
Description: Response helpers for Hattip
Author: Fatih Aygün
Latest version: 0.0.49

# `@hattip/response`

Response utilities for Hattip. This package exports three functions for creating several response types:

## `text`

Creates a response with the given text. The content type is set to `text/plain; charset=utf-8` unless explicitly specified.

```js
// Basic usage
text("Hello, world!");
// You can customize status and headers
text("Bad request", { status: 400 });
```

## `json`

Creates a response with the given JSON object. The content type is set to `application/json; charset=utf-8` unless explicitly specified.

```js
// Basic usage
json({ hello: "world" });
// You can customize status and headers
json({ error: "Nad request" }, { status: 400 });
```

## `html`

Creates a response with the given HTML string. The content type is set to `text/html; charset=utf-8` unless explicitly specified.

```js
// Basic usage
html("<h1>Hello, world!</h1>");
// You can customize status and headers
html("<h1>Bad request</h1>", { status: 400 });
```

## `serverSentEvents`

Creates a response that emits server-sent events.

```js
serverSentEvents({
  onOpen(sink) {
    // Use `sink` to send events
    sink.send({ type: "custom", data: "Hello, world!", id: "1" });
    // Short hand for sending a message
    sink.sendMessage("Hello, world!");
  },
  onClose() {
    // You can use this to clean up resources
    // No more events can be sent after this is called
  },
});
```

`serverSentEvents` is intentionally very low-level. It doesn't handle data serialization (it only accepts strings), or keep track of connections, event IDs, or the `Last-Event-ID` header. But it is very flexible and allows you to implement your own logic for a full pub/sub system.

`serverSentEvents` works on all adapters that support streaming responses but since it requires a long-running server, using it with edge runtimes is not very useful. It leaves Node (optionally with uWebSockets.js) and Deno as the only real options. In particular, Bun and AWS-based serverless offerings of Netlify and Vercel don't support streaming responses.
npm package: @hattip/router
Description: Express-style imperative router for Hattip
Author: Fatih Aygün
Latest version: 0.0.49

# `@hattip/router`

Express-style imperative router for Hattip.

## Usage

```js
import { createRouter } from "@hattip/router";
import { cookie } from "@hattip/cookie";

const app = createRouter();

// Add middleware
app.use(cookie());

// GET /
app.get("/", () => new Response("Hello, world!"));

// POST /echo
app.post("/echo", async (ctx) => new Response(await ctx.request.text()));

// DELETE /book/:title where :title is a route parameter
app.delete("/book/:title", async (ctx) => {
  // Parameters are available in ctx.params
  return new Response(`Deleted book: ${ctx.params.title}`);
});

export default app.buildHandler();
```

## API

- `createRouter()`: Creates a new router.
- `router.<method>(handler)`: Adds a handler for the given method and all paths.
- `router.<method>(path, handler)`: Adds a handler for the given method and path.

  `path` can be a string or a regular expression. If it's a string, parameters can be specified using `:` followed by the parameter name like `/book/:title`. `*` can be used to match any number of characters.

  `<method>` is the HTTP method in lowercase (e.g. `get`, `post`, `delete`).

  `handler` is a request handler.

- `router.use(path, handler)`: Adds a handler for all methods and the given path.
- `router.use(handler)`: Adds a handler for all methods and all paths.
- `router.handlers`: Returns an array of handlers.
- `router.buildHandler()`: Returns a handler that can be passed to an adapter.

`@hattip/router` extends the `RequestContext` object with a `params` property which contains a map of parameters extracted from a dynamic route.