remix 3.0.0-beta.0 → 3.0.0-beta.2

package/src/session-storage-memcache/README.md

@@ -0,0 +1,37 @@
+# session-storage-memcache
+
+Memcache session storage for [`remix/session`](https://github.com/remix-run/remix/tree/main/packages/session).
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+```ts
+import { createMemcacheSessionStorage } from 'remix/session-storage/memcache'
+
+let sessionStorage = createMemcacheSessionStorage('127.0.0.1:11211', {
+  keyPrefix: 'my-app:session:',
+  ttlSeconds: 60 * 60 * 24 * 7,
+})
+```
+
+Available options:
+
+- `useUnknownIds` (default: `false`) - reuse unknown session IDs sent by the client
+- `keyPrefix` (default: `'remix:session:'`) - prefix for all Memcache keys
+- `ttlSeconds` (default: `0`) - session expiration in seconds (`0` means no expiration)
+
+Note: Memcache storage uses TCP sockets and requires a Node.js runtime.
+
+## Related Packages
+
+- [`remix/session`](https://github.com/remix-run/remix/tree/main/packages/session) - Core session primitives and storage interface
+- [`remix/middleware/session`](https://github.com/remix-run/remix/tree/main/packages/session-middleware) - Middleware for wiring session storage into request handling
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/session-storage-redis/README.md

@@ -0,0 +1,37 @@
+# session-storage-redis
+
+Redis-backed session storage for [`remix/session`](https://github.com/remix-run/remix/tree/main/packages/session).
+Use this package when app servers need to share session state through Redis.
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+```ts
+import { createClient } from 'redis'
+import { createRedisSessionStorage } from 'remix/session-storage/redis'
+
+let redis = createClient({ url: process.env.REDIS_URL })
+await redis.connect()
+
+let sessionStorage = createRedisSessionStorage(redis, {
+  keyPrefix: 'session:',
+  ttl: 60 * 60 * 24,
+})
+```
+
+## Options
+
+`createRedisSessionStorage(client, options)` supports:
+
+- `keyPrefix` (`string`, default: `'session:'`)
+- `ttl` (`number` seconds)
+- `useUnknownIds` (`boolean`, default: `false`)
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/static-middleware/README.md

@@ -0,0 +1,89 @@
+# static-middleware
+
+Static file serving middleware for Remix. Serves static files from a directory with support for ETags, range requests, and conditional requests.
+
+## Features
+
+- [ETag](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) support (weak and strong)
+- [Range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests) support (HTTP 206 Partial Content)
+- [Conditional request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Conditional_requests) support (If-None-Match, If-Modified-Since)
+- Path traversal protection
+- Automatic fallback to next middleware/handler if file not found
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+Static middleware is useful for serving static files from a directory.
+
+```ts
+import { createRouter } from 'remix/router'
+import { staticFiles } from 'remix/middleware/static'
+
+let router = createRouter({
+  middleware: [staticFiles('./public')],
+})
+
+router.get('/', () => new Response('Home'))
+```
+
+### With Cache Control
+
+Internally, the `staticFiles()` middleware uses the [`createFileResponse()` helper from `remix/response`](https://github.com/remix-run/remix/tree/main/packages/response/README.md#file-responses) to send files with full HTTP semantics. This means it also accepts the same options as the `createFileResponse()` helper.
+
+```ts
+let router = createRouter({
+  middleware: [
+    staticFiles('./public', {
+      cacheControl: 'public, max-age=31536000, immutable', // 1 year
+    }),
+  ],
+})
+```
+
+### Filter Files
+
+```ts
+let router = createRouter({
+  middleware: [
+    staticFiles('./public', {
+      filter(path) {
+        // Don't serve hidden files
+        return !path.startsWith('.')
+      },
+    }),
+  ],
+})
+```
+
+### Multiple Directories
+
+```ts
+let router = createRouter({
+  middleware: [
+    staticFiles('./public'),
+    staticFiles('./assets', {
+      cacheControl: 'public, max-age=31536000',
+    }),
+  ],
+})
+```
+
+## Security
+
+- Prevents path traversal attacks (e.g., `../../../etc/passwd`)
+- Only serves files with GET and HEAD requests
+- Respects the configured root directory boundary
+
+## Related Packages
+
+- [`fetch-router`](https://github.com/remix-run/remix/tree/main/packages/fetch-router) - Router for the web Fetch API
+- [`lazy-file`](https://github.com/remix-run/remix/tree/main/packages/lazy-file) - Used internally for streaming file contents
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/tar-parser/README.md

@@ -0,0 +1,74 @@
+# tar-parser
+
+Streaming [tar archive](<https://en.wikipedia.org/wiki/Tar_(computing)>) parsing for JavaScript. `tar-parser` handles POSIX/GNU/PAX archives incrementally so large tar files can be processed without buffering the full payload.
+
+## Features
+
+- **Universal Runtime** - Runs anywhere JavaScript runs
+- **Web Streams** - Built on the standard [web Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API), so it's composable with `fetch()` streams
+- **Format Support** - Supports POSIX, GNU, and PAX tar formats
+- **Memory Efficient** - Does not buffer anything in normal usage
+- **Zero Dependencies** - No external dependencies
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+The main parser interface is the `parseTar(archive, handler)` function:
+
+```ts
+import { parseTar } from 'remix/tar-parser'
+
+let response = await fetch('https://github.com/remix-run/remix/archive/refs/heads/main.tar.gz')
+
+await parseTar(response.body.pipeThrough(new DecompressionStream('gzip')), (entry) => {
+  console.log(entry.name, entry.size)
+})
+```
+
+If you're parsing an archive with filename encodings other than UTF-8, use the `filenameEncoding` option:
+
+```ts
+let response = await fetch(/* ... */)
+
+await parseTar(response.body, { filenameEncoding: 'latin1' }, (entry) => {
+  console.log(entry.name, entry.size)
+})
+```
+
+## Benchmark
+
+`tar-parser` performs on par with other popular tar parsing libraries on Node.js.
+
+```
+> @remix-run/tar-parser@0.0.0 bench /Users/michael/Projects/remix-the-web/packages/tar-parser
+> node ./bench/runner.ts
+
+Platform: Darwin (24.0.0)
+CPU: Apple M1 Pro
+Date: 12/6/2024, 11:00:55 AM
+Node.js v22.8.0
+┌────────────┬────────────────────┐
+│ (index)    │ lodash npm package │
+├────────────┼────────────────────┤
+│ tar-parser │ '6.23 ms ± 0.58'   │
+│ tar-stream │ '6.72 ms ± 2.24'   │
+│ node-tar   │ '6.49 ms ± 0.44'   │
+└────────────┴────────────────────┘
+```
+
+## Related Packages
+
+- [`multipart-parser`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser) - Fast, streaming multipart parser for JavaScript
+
+## Credits
+
+`tar-parser` is based on the excellent [tar-stream package](https://www.npmjs.com/package/tar-stream) (MIT license) and adopts the same core parsing algorithm, utility functions, and many test cases.
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/src/terminal/README.md

@@ -0,0 +1,92 @@
+# terminal
+
+Terminal output utilities for JavaScript libraries and CLIs. It provides small primitives for ANSI styles, color support detection, escape sequences, and testable stdout/stderr handling.
+
+## Features
+
+- **ANSI Styles** - Apply common modifiers, foreground colors, and background colors
+- **Color Detection** - Respect `CI`, `NO_COLOR`, `FORCE_COLOR`, `TERM=dumb`, TTY streams, and explicit style overrides
+- **Terminal Controls** - Generate escape sequences for cursor movement, line clearing, and cursor visibility
+- **Testable Streams** - Create terminal instances around injected stdout/stderr/stdin streams
+
+## Installation
+
+```sh
+npm i remix
+```
+
+## Usage
+
+```ts
+import { createTerminal } from 'remix/terminal'
+
+let terminal = createTerminal()
+
+terminal.writeLine(`${terminal.styles.green('ready')} listening on port 3000`)
+terminal.errorLine(terminal.styles.red('failed to start'))
+```
+
+### ANSI Styles
+
+Use `createStyles` when you only need formatting helpers.
+
+```ts
+import { createStyles } from 'remix/terminal'
+
+let styles = createStyles({ colors: true })
+
+console.log(styles.bold(styles.cyan('Ready')))
+console.log(styles.format('warning', 'dim', 'yellow', 'bgBlackBright'))
+```
+
+Style helpers preserve outer styles when nested formatted strings close an inner style.
+
+```ts
+console.log(styles.red(`Error: ${styles.bold('fatal')} retrying`))
+```
+
+Supported modifiers include `bold`, `dim`, `italic`, `underline`, `overline`, `inverse`, and `strikethrough`. Supported colors include the base foreground/background ANSI colors, bright variants, and `gray`/`grey` aliases.
+
+By default, color detection disables styles in CI, when `NO_COLOR` is present, for `TERM=dumb`, and outside TTY output streams. Set `colors` to `true` or `false` to override automatic detection.
+
+### Terminal Controls
+
+Use `ansi` for raw terminal escape sequences.
+
+```ts
+import { ansi } from 'remix/terminal'
+
+process.stdout.write(ansi.clearLine)
+process.stdout.write(ansi.cursorTo(0))
+process.stdout.write('Updated status')
+```
+
+### Testing Output
+
+Inject streams to test terminal output without writing to the real console.
+
+```ts
+import { createTerminal } from 'remix/terminal'
+
+let output = ''
+
+let terminal = createTerminal({
+  colors: false,
+  stdout: {
+    write(chunk) {
+      output += chunk
+    },
+  },
+})
+
+terminal.writeLine(terminal.styles.green('ok'))
+```
+
+## Related Packages
+
+- [`logger-middleware`](https://github.com/remix-run/remix/tree/main/packages/logger-middleware) - HTTP request/response logging middleware
+- [`test`](https://github.com/remix-run/remix/tree/main/packages/test) - Browser-based test framework for Remix components
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)