prjct-cli 0.35.1 → 0.35.3

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/websocket/context.mdx

@@ -1,79 +0,0 @@
----
-title: Set per-socket contextual data on a WebSocket
-sidebarTitle: Contextual data
-mode: center
----
-
-When building a WebSocket server, it's typically necessary to store some identifying information or context associated with each connected client.
-
-With [Bun.serve()](/docs/runtime/http/websockets#contextual-data), this "contextual data" is set when the connection is initially upgraded by passing a `data` parameter in the `server.upgrade()` call.
-
-```ts server.ts icon="/icons/typescript.svg"
-Bun.serve({
-  fetch(req, server) {
-    const success = server.upgrade(req, {
-      data: {
-        socketId: Math.random(),
-      },
-    });
-    if (success) return undefined;
-
-    // handle HTTP request normally
-    // ...
-  },
-  websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { socketId: number },
-
-    // define websocket handlers
-    async message(ws, message) {
-      // the contextual data is available as the `data` property
-      // on the WebSocket instance
-      console.log(`Received ${message} from ${ws.data.socketId}}`);
-    },
-  },
-});
-```
-
----
-
-It's common to read cookies/headers from the incoming request to identify the connecting client.
-
-```ts server.ts icon="/icons/typescript.svg"
-type WebSocketData = {
-  createdAt: number;
-  token: string;
-  userId: string;
-};
-
-Bun.serve({
-  async fetch(req, server) {
-    // use a library to parse cookies
-    const cookies = parseCookies(req.headers.get("Cookie"));
-    const token = cookies["X-Token"];
-    const user = await getUserFromToken(token);
-
-    const upgraded = server.upgrade(req, {
-      data: {
-        createdAt: Date.now(),
-        token: cookies["X-Token"],
-        userId: user.id,
-      },
-    });
-
-    if (upgraded) return undefined;
-  },
-  websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as WebSocketData,
-
-    async message(ws, message) {
-      // save the message to a database
-      await saveMessageToDatabase({
-        message: String(message),
-        userId: ws.data.userId,
-      });
-    },
-  },
-});
-```

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/websocket/pubsub.mdx

@@ -1,43 +0,0 @@
----
-title: Build a publish-subscribe WebSocket server
-sidebarTitle: Pub-sub server
-mode: center
----
-
-Bun's server-side `WebSocket` API provides a native pub-sub API. Sockets can be subscribed to a set of named channels using `socket.subscribe(<name>)`; messages can be published to a channel using `socket.publish(<name>, <message>)`.
-
-This code snippet implements a simple single-channel chat server.
-
-```ts server.ts icon="/icons/typescript.svg"
-const server = Bun.serve({
-  fetch(req, server) {
-    const cookies = req.headers.get("cookie");
-    const username = getUsernameFromCookies(cookies);
-    const success = server.upgrade(req, { data: { username } });
-    if (success) return undefined;
-
-    return new Response("Hello world");
-  },
-  websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { username: string },
-
-    open(ws) {
-      const msg = `${ws.data.username} has entered the chat`;
-      ws.subscribe("the-group-chat");
-      server.publish("the-group-chat", msg);
-    },
-    message(ws, message) {
-      // the server re-broadcasts incoming messages to everyone
-      server.publish("the-group-chat", `${ws.data.username}: ${message}`);
-    },
-    close(ws) {
-      const msg = `${ws.data.username} has left the chat`;
-      server.publish("the-group-chat", msg);
-      ws.unsubscribe("the-group-chat");
-    },
-  },
-});
-
-console.log(`Listening on ${server.hostname}:${server.port}`);
-```

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/websocket/simple.mdx

@@ -1,38 +0,0 @@
----
-title: Build a simple WebSocket server
-sidebarTitle: Simple server
-mode: center
----
-
-Start a simple WebSocket server using [`Bun.serve`](/docs/runtime/http/server).
-
-Inside `fetch`, we attempt to upgrade incoming `ws:` or `wss:` requests to WebSocket connections.
-
-```ts server.ts icon="/icons/typescript.svg"
-const server = Bun.serve({
-  fetch(req, server) {
-    const success = server.upgrade(req);
-    if (success) {
-      // Bun automatically returns a 101 Switching Protocols
-      // if the upgrade succeeds
-      return undefined;
-    }
-
-    // handle HTTP request normally
-    return new Response("Hello world!");
-  },
-  websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { authToken: string },
-
-    // this is called when a message is received
-    async message(ws, message) {
-      console.log(`Received ${message}`);
-      // send back a message
-      ws.send(`You said: ${message}`);
-    },
-  },
-});
-
-console.log(`Listening on ${server.hostname}:${server.port}`);
-```

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/append.mdx

@@ -1,54 +0,0 @@
----
-title: Append content to a file
-sidebarTitle: Append to file
-mode: center
----
-
-Bun implements the `node:fs` module, which includes the `fs.appendFile` and `fs.appendFileSync` functions for appending content to files.
-
----
-
-You can use `fs.appendFile` to asynchronously append data to a file, creating the file if it does not yet exist. The content can be a string or a `Buffer`.
-
-```ts
-import { appendFile } from "node:fs/promises";
-
-await appendFile("message.txt", "data to append");
-```
-
----
-
-To use the non-`Promise` API:
-
-```ts
-import { appendFile } from "node:fs";
-
-appendFile("message.txt", "data to append", err => {
-  if (err) throw err;
-  console.log('The "data to append" was appended to file!');
-});
-```
-
----
-
-To specify the encoding of the content:
-
-```js
-import { appendFile } from "node:fs";
-
-appendFile("message.txt", "data to append", "utf8", callback);
-```
-
----
-
-To append the data synchronously, use `fs.appendFileSync`:
-
-```ts
-import { appendFileSync } from "node:fs";
-
-appendFileSync("message.txt", "data to append", "utf8");
-```
-
----
-
-See the [Node.js documentation](https://nodejs.org/api/fs.html#fspromisesappendfilepath-data-options) for more information.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/basic.mdx

@@ -1,46 +0,0 @@
----
-title: Write a string to a file
-sidebarTitle: Write string to file
-mode: center
----
-
-This code snippet writes a string to disk at a particular _absolute path_.
-
-It uses the fast [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write) API to efficiently write data to disk. The first argument is a _destination_; the second is the _data_ to write.
-
-```ts
-const path = "/path/to/file.txt";
-await Bun.write(path, "Lorem ipsum");
-```
-
----
-
-Any relative paths will be resolved relative to the project root (the nearest directory containing a `package.json` file).
-
-```ts
-const path = "./file.txt";
-await Bun.write(path, "Lorem ipsum");
-```
-
----
-
-You can pass a `BunFile` as the destination. `Bun.write()` will write the data to its associated path.
-
-```ts
-const path = Bun.file("./file.txt");
-await Bun.write(path, "Lorem ipsum");
-```
-
----
-
-`Bun.write()` returns the number of bytes written to disk.
-
-```ts
-const path = "./file.txt";
-const bytes = await Bun.write(path, "Lorem ipsum");
-// => 11
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/blob.mdx

@@ -1,30 +0,0 @@
----
-title: Write a Blob to a file
-sidebarTitle: Write Blob
-mode: center
----
-
-This code snippet writes a `Blob` to disk at a particular path.
-
-It uses the fast [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write) API to efficiently write data to disk. The first argument is a _destination_, like an absolute path or `BunFile` instance. The second argument is the _data_ to write.
-
-```ts
-const path = "/path/to/file.txt";
-await Bun.write(path, "Lorem ipsum");
-```
-
----
-
-The `BunFile` class extends `Blob`, so you can pass a `BunFile` directly into `Bun.write()` as well.
-
-```ts
-const path = "./out.txt";
-const data = Bun.file("./in.txt");
-
-// write the contents of ./in.txt to ./out.txt
-await Bun.write(path, data);
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/cat.mdx

@@ -1,19 +0,0 @@
----
-title: Write a file to stdout
-sidebarTitle: Write file to stdout
-mode: center
----
-
-Bun exposes `stdout` as a `BunFile` with the `Bun.stdout` property. This can be used as a destination for [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write).
-
-This code writes a file to `stdout` similar to the `cat` command in Unix.
-
-```ts cat.ts icon="/icons/typescript.svg"
-const path = "/path/to/file.txt";
-const file = Bun.file(path);
-await Bun.write(Bun.stdout, file);
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/file-cp.mdx

@@ -1,18 +0,0 @@
----
-title: Copy a file to another location
-sidebarTitle: Copy file
-mode: center
----
-
-This code snippet copies a file to another location on disk.
-
-It uses the fast [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write) API to efficiently write data to disk. The first argument is a _destination_, like an absolute path or `BunFile` instance. The second argument is the _data_ to write.
-
-```ts
-const file = Bun.file("/path/to/original.txt");
-await Bun.write("/path/to/copy.txt", file);
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/filesink.mdx

@@ -1,54 +0,0 @@
----
-title: Write a file incrementally
-sidebarTitle: Incremental write
-mode: center
----
-
-Bun provides an API for incrementally writing to a file. This is useful for writing large files, or for writing to a file over a long period of time.
-
-Call `.writer()` on a `BunFile` to retrieve a `FileSink` instance. This instance can be used to efficiently buffer data and periodically "flush" it to disk. You can write & flush many times.
-
-```ts
-const file = Bun.file("/path/to/file.txt");
-const writer = file.writer();
-
-writer.write("lorem");
-writer.write("ipsum");
-writer.write("dolor");
-
-writer.flush();
-
-// continue writing & flushing
-```
-
----
-
-The `.write()` method can accept strings or binary data.
-
-```ts
-w.write("hello");
-w.write(Buffer.from("there"));
-w.write(new Uint8Array([0, 255, 128]));
-writer.flush();
-```
-
----
-
-The `FileSink` will also auto-flush when its internal buffer is full. You can configure the buffer size with the `highWaterMark` option.
-
-```ts
-const file = Bun.file("/path/to/file.txt");
-const writer = file.writer({ highWaterMark: 1024 * 1024 }); // 1MB
-```
-
----
-
-When you're done writing to the file, call `.end()` to auto-flush the buffer and close the file.
-
-```ts
-writer.end();
-```
-
----
-
-Full documentation: [FileSink](/docs/runtime/file-io#incremental-writing-with-filesink).

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/response.mdx

@@ -1,19 +0,0 @@
----
-title: Write a Response to a file
-sidebarTitle: Write Response
-mode: center
----
-
-This code snippet writes a `Response` to disk at a particular path. Bun will consume the `Response` body according to its `Content-Type` header.
-
-It uses the fast [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write) API to efficiently write data to disk. The first argument is a _destination_, like an absolute path or `BunFile` instance. The second argument is the _data_ to write.
-
-```ts
-const result = await fetch("https://bun.com");
-const path = "./file.txt";
-await Bun.write(path, result);
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/stdout.mdx

@@ -1,23 +0,0 @@
----
-title: Write to stdout
-sidebarTitle: Write to stdout
-mode: center
----
-
-The `console.log` function writes to `stdout`. It will automatically append a line break at the end of the printed data.
-
-```ts
-console.log("Lorem ipsum");
-```
-
----
-
-For more advanced use cases, Bun exposes `stdout` as a `BunFile` via the `Bun.stdout` property. This can be used as a destination for [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write).
-
-```ts
-await Bun.write(Bun.stdout, "Lorem ipsum");
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/stream.mdx

@@ -1,19 +0,0 @@
----
-title: Write a ReadableStream to a file
-sidebarTitle: Write stream
-mode: center
----
-
-To write a `ReadableStream` to disk, first create a `Response` instance from the stream. This `Response` can then be written to disk using [`Bun.write()`](/docs/runtime/file-io#writing-files-bun-write).
-
-```ts
-const stream: ReadableStream = ...;
-const path = "./file.txt";
-const response = new Response(stream);
-
-await Bun.write(path, response);
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#writing-files-bun-write) for complete documentation of `Bun.write()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/write-file/unlink.mdx

@@ -1,18 +0,0 @@
----
-title: Delete a file
-sidebarTitle: Delete file
-mode: center
----
-
-The `Bun.file()` function accepts a path and returns a `BunFile` instance. Use the `.delete()` method to delete the file.
-
-```ts
-const path = "/path/to/file.txt";
-const file = Bun.file(path);
-
-await file.delete();
-```
-
----
-
-See [Docs > API > File I/O](/docs/runtime/file-io#reading-files-bun-file) for complete documentation of `Bun.file()`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/index.mdx

@@ -1,133 +0,0 @@
----
-title: Welcome to Bun
-description: Bun is an all-in-one toolkit for developing modern JavaScript/TypeScript applications.
-mode: center
----
-
-<CardGroup>
-  <Card
-    icon="cog"
-    title="Bun Runtime"
-    href="/runtime"
-    cta={
-      <span>
-        Get started with <code>bun run</code>
-      </span>
-    }
-  >
-    A fast JavaScript runtime designed as a drop-in replacement for Node.js
-  </Card>
-  <Card
-    icon="box"
-    title="Bun Package Manager"
-    href="/pm/cli/install"
-    cta={
-      <span>
-        Get started with <code>bun install</code>
-      </span>
-    }
-  >
-    Install packages up to 30x faster than npm with a global cache and workspaces
-  </Card>
-  <Card
-    icon="flask-conical"
-    title="Bun Test Runner"
-    href="/test"
-    cta={
-      <span>
-        Get started with <code>bun test</code>
-      </span>
-    }
-  >
-    Jest-compatible, TypeScript-first tests with snapshots, DOM, and watch mode
-  </Card>
-  <Card
-    icon="combine"
-    title="Bun Bundler"
-    href="/bundler"
-    cta={
-      <span>
-        Get started with <code>bun build</code>
-      </span>
-    }
-  >
-    Bundle TypeScript, JSX, React & CSS for both browsers and servers
-  </Card>
-</CardGroup>
-
----
-
-## Get Started
-
-Bun ships as a single, dependency-free binary and includes a runtime, package manager, test runner, and bundler. New to Bun?
-
-<CardGroup>
-  <Card icon="download" title="Install Bun" href="/installation">
-    Supported platforms and all install methods.
-  </Card>
-  <Card icon="zap" title="Quickstart" href="/quickstart">
-    Hello world in minutes with Bun.serve.
-  </Card>
-</CardGroup>
-
----
-
-## What's Inside
-
-- Runtime: Execute JavaScript/TypeScript files and package scripts with near-zero overhead.
-- Package Manager: Fast installs, workspaces, overrides, and audits with `bun install`.
-- Test Runner: Jest-compatible, TypeScript-first tests with snapshots, DOM, and watch mode.
-- Bundler: Native bundling for JS/TS/JSX with splitting, plugins, and HTML imports.
-
-Explore each area using the cards above. Each section is structured with an overview, quick examples, reference, and best practices for fast scanning and deep dives.
-
----
-
-## What is Bun?
-
-Bun is an all-in-one toolkit for JavaScript and TypeScript apps. It ships as a single executable called `bun`.
-
-At its core is the _Bun runtime_, a fast JavaScript runtime designed as **a drop-in replacement for Node.js**. It's written in Zig and powered by JavaScriptCore under the hood, dramatically reducing startup times and memory usage.
-
-```bash terminal icon="terminal"
-bun run index.tsx  # TS and JSX supported out of the box
-```
-
-The `bun` command-line tool also implements a test runner, script runner, and Node.js-compatible package manager, all significantly faster than existing tools and usable in existing Node.js projects with little to no changes necessary.
-
-```bash terminal icon="terminal"
-bun run start                 # run the `start` script
-bun install <pkg>             # install a package
-bun build ./index.tsx         # bundle a project for browsers
-bun test                      # run tests
-bunx cowsay 'Hello, world!'   # execute a package
-```
-
-## What is a runtime?
-
-JavaScript (or, more formally, ECMAScript) is just a _specification_ for a programming language. Anyone can write a JavaScript _engine_ that ingests a valid JavaScript program and executes it. The two most popular engines in use today are V8 (developed by Google)
-and JavaScriptCore (developed by Apple). Both are open source.
-
-But most JavaScript programs don't run in a vacuum. They need a way to access the outside world to perform useful tasks. This is where _runtimes_ come in. They implement additional APIs that are then made available to the JavaScript programs they execute.
-
-### Browsers
-
-Notably, browsers ship with JavaScript runtimes that implement a set of Web-specific APIs that are exposed via the global `window` object. Any JavaScript code executed by the browser can use these APIs to implement interactive or dynamic behavior in the context of the current webpage.
-
-### Node.js
-
-Similarly, Node.js is a JavaScript runtime that can be used in non-browser environments, like servers. JavaScript programs executed by Node.js have access to a set of Node.js-specific [globals](https://nodejs.org/api/globals.html) like `Buffer`, `process`, and `__dirname` in addition to built-in modules for performing OS-level tasks like reading/writing files (`node:fs`) and networking (`node:net`, `node:http`). Node.js also implements a CommonJS-based module system and resolution algorithm that pre-dates JavaScript's native module system.
-
-Bun is designed as a faster, leaner, more modern replacement for Node.js.
-
-## Design goals
-
-Bun is designed from the ground-up with today's JavaScript ecosystem in mind.
-
-- **Speed**. Bun processes start [4x faster than Node.js](https://twitter.com/jarredsumner/status/1499225725492076544) currently (try it yourself!)
-- **TypeScript & JSX support**. You can directly execute `.jsx`, `.ts`, and `.tsx` files; Bun's transpiler converts these to vanilla JavaScript before execution.
-- **ESM & CommonJS compatibility**. The world is moving towards ES modules (ESM), but millions of packages on npm still require CommonJS. Bun recommends ES modules, but supports CommonJS.
-- **Web-standard APIs**. Bun implements standard Web APIs like `fetch`, `WebSocket`, and `ReadableStream`. Bun is powered by the JavaScriptCore engine, which is developed by Apple for Safari, so some APIs like [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) and [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) directly use [Safari's implementation](https://github.com/oven-sh/bun/blob/HEAD/src/bun.js/bindings/webcore/JSFetchHeaders.cpp).
-- **Node.js compatibility**. In addition to supporting Node-style module resolution, Bun aims for full compatibility with built-in Node.js globals (`process`, `Buffer`) and modules (`path`, `fs`, `http`, etc.) _This is an ongoing effort that is not complete._ Refer to the [compatibility page](/docs/runtime/nodejs-compat) for the current status.
-
-Bun is more than a runtime. The long-term goal is to be a cohesive, infrastructural toolkit for building apps with JavaScript/TypeScript, including a package manager, transpiler, bundler, script runner, test runner, and more.