@hasna/connectors 1.3.10 → 1.3.11

package/connectors/connect-yousign/node_modules/bun-types/docs/runtime/file-io.mdx

@@ -1,306 +0,0 @@
----
-title: File I/O
-description: Bun provides a set of optimized APIs for reading and writing files.
----
-
-<Note>
-
-The `Bun.file` and `Bun.write` APIs documented on this page are heavily optimized and represent the recommended way to perform file-system tasks using Bun. For operations that are not yet available with `Bun.file`, such as `mkdir` or `readdir`, you can use Bun's [nearly complete](/docs/runtime/nodejs-compat#node-fs) implementation of the [`node:fs`](https://nodejs.org/api/fs.html) module.
-
-</Note>
-
----
-
-## Reading files (`Bun.file()`)
-
-`Bun.file(path): BunFile`
-
-Create a `BunFile` instance with the `Bun.file(path)` function. A `BunFile` represents a lazily-loaded file; initializing it does not actually read the file from disk.
-
-```ts
-const foo = Bun.file("foo.txt"); // relative to cwd
-foo.size; // number of bytes
-foo.type; // MIME type
-```
-
-The reference conforms to the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) interface, so the contents can be read in various formats.
-
-```ts
-const foo = Bun.file("foo.txt");
-
-await foo.text(); // contents as a string
-await foo.json(); // contents as a JSON object
-await foo.stream(); // contents as ReadableStream
-await foo.arrayBuffer(); // contents as ArrayBuffer
-await foo.bytes(); // contents as Uint8Array
-```
-
-File references can also be created using numerical [file descriptors](https://en.wikipedia.org/wiki/File_descriptor) or `file://` URLs.
-
-```ts
-Bun.file(1234);
-Bun.file(new URL(import.meta.url)); // reference to the current file
-```
-
-A `BunFile` can point to a location on disk where a file does not exist.
-
-```ts
-const notreal = Bun.file("notreal.txt");
-notreal.size; // 0
-notreal.type; // "text/plain;charset=utf-8"
-const exists = await notreal.exists(); // false
-```
-
-The default MIME type is `text/plain;charset=utf-8`, but it can be overridden by passing a second argument to `Bun.file`.
-
-```ts
-const notreal = Bun.file("notreal.json", { type: "application/json" });
-notreal.type; // => "application/json;charset=utf-8"
-```
-
-For convenience, Bun exposes `stdin`, `stdout` and `stderr` as instances of `BunFile`.
-
-```ts
-Bun.stdin; // readonly
-Bun.stdout;
-Bun.stderr;
-```
-
-### Deleting files (`file.delete()`)
-
-You can delete a file by calling the `.delete()` function.
-
-```ts
-await Bun.file("logs.json").delete();
-```
-
----
-
-## Writing files (`Bun.write()`)
-
-`Bun.write(destination, data): Promise<number>`
-
-The `Bun.write` function is a multi-tool for writing payloads of all kinds to disk.
-
-The first argument is the `destination` which can have any of the following types:
-
-- `string`: A path to a location on the file system. Use the `"path"` module to manipulate paths.
-- `URL`: A `file://` descriptor.
-- `BunFile`: A file reference.
-
-The second argument is the data to be written. It can be any of the following:
-
-- `string`
-- `Blob` (including `BunFile`)
-- `ArrayBuffer` or `SharedArrayBuffer`
-- `TypedArray` (`Uint8Array`, et. al.)
-- `Response`
-
-All possible permutations are handled using the fastest available system calls on the current platform.
-
-<Accordion title="See syscalls">
-
-| Output               | Input          | System call                   | Platform |
-| -------------------- | -------------- | ----------------------------- | -------- |
-| file                 | file           | copy_file_range               | Linux    |
-| file                 | pipe           | sendfile                      | Linux    |
-| pipe                 | pipe           | splice                        | Linux    |
-| terminal             | file           | sendfile                      | Linux    |
-| terminal             | terminal       | sendfile                      | Linux    |
-| socket               | file or pipe   | sendfile (if http, not https) | Linux    |
-| file (doesn't exist) | file (path)    | clonefile                     | macOS    |
-| file (exists)        | file           | fcopyfile                     | macOS    |
-| file                 | Blob or string | write                         | macOS    |
-| file                 | Blob or string | write                         | Linux    |
-
-</Accordion>
-
-To write a string to disk:
-
-```ts
-const data = `It was the best of times, it was the worst of times.`;
-await Bun.write("output.txt", data);
-```
-
-To copy a file to another location on disk:
-
-```ts
-const input = Bun.file("input.txt");
-const output = Bun.file("output.txt"); // doesn't exist yet!
-await Bun.write(output, input);
-```
-
-To write a byte array to disk:
-
-```ts
-const encoder = new TextEncoder();
-const data = encoder.encode("datadatadata"); // Uint8Array
-await Bun.write("output.txt", data);
-```
-
-To write a file to `stdout`:
-
-```ts
-const input = Bun.file("input.txt");
-await Bun.write(Bun.stdout, input);
-```
-
-To write the body of an HTTP response to disk:
-
-```ts
-const response = await fetch("https://bun.com");
-await Bun.write("index.html", response);
-```
-
----
-
-## Incremental writing with `FileSink`
-
-Bun provides a native incremental file writing API called `FileSink`. To retrieve a `FileSink` instance from a `BunFile`:
-
-```ts
-const file = Bun.file("output.txt");
-const writer = file.writer();
-```
-
-To incrementally write to the file, call `.write()`.
-
-```ts
-const file = Bun.file("output.txt");
-const writer = file.writer();
-
-writer.write("it was the best of times\n");
-writer.write("it was the worst of times\n");
-```
-
-These chunks will be buffered internally. To flush the buffer to disk, use `.flush()`. This returns the number of flushed bytes.
-
-```ts
-writer.flush(); // write buffer to disk
-```
-
-The buffer will also auto-flush when the `FileSink`'s _high water mark_ is reached; that is, when its internal buffer is full. This value can be configured.
-
-```ts
-const file = Bun.file("output.txt");
-const writer = file.writer({ highWaterMark: 1024 * 1024 }); // 1MB
-```
-
-To flush the buffer and close the file:
-
-```ts
-writer.end();
-```
-
-Note that, by default, the `bun` process will stay alive until this `FileSink` is explicitly closed with `.end()`. To opt out of this behavior, you can "unref" the instance.
-
-```ts
-writer.unref();
-
-// to "re-ref" it later
-writer.ref();
-```
-
----
-
-## Directories
-
-Bun's implementation of `node:fs` is fast, and we haven't implemented a Bun-specific API for reading directories just yet. For now, you should use `node:fs` for working with directories in Bun.
-
-### Reading directories (readdir)
-
-To read a directory in Bun, use `readdir` from `node:fs`.
-
-```ts
-import { readdir } from "node:fs/promises";
-
-// read all the files in the current directory
-const files = await readdir(import.meta.dir);
-```
-
-#### Reading directories recursively
-
-To recursively read a directory in Bun, use `readdir` with `recursive: true`.
-
-```ts
-import { readdir } from "node:fs/promises";
-
-// read all the files in the current directory, recursively
-const files = await readdir("../", { recursive: true });
-```
-
-### Creating directories (mkdir)
-
-To recursively create a directory, use `mkdir` in `node:fs`:
-
-```ts
-import { mkdir } from "node:fs/promises";
-
-await mkdir("path/to/dir", { recursive: true });
-```
-
----
-
-## Benchmarks
-
-The following is a 3-line implementation of the Linux `cat` command.
-
-```ts cat.ts icon="/icons/typescript.svg"
-// Usage
-// bun ./cat.ts ./path-to-file
-
-import { resolve } from "path";
-
-const path = resolve(process.argv.at(-1));
-await Bun.write(Bun.stdout, Bun.file(path));
-```
-
-To run the file:
-
-```bash terminal icon="terminal"
-bun ./cat.ts ./path-to-file
-```
-
-It runs 2x faster than GNU `cat` for large files on Linux.
-
-<Frame>![Cat screenshot](https://bun.com/images/cat.jpg)</Frame>
-
----
-
-## Reference
-
-```ts
-interface Bun {
-  stdin: BunFile;
-  stdout: BunFile;
-  stderr: BunFile;
-
-  file(path: string | number | URL, options?: { type?: string }): BunFile;
-
-  write(
-    destination: string | number | BunFile | URL,
-    input: string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response,
-  ): Promise<number>;
-}
-
-interface BunFile {
-  readonly size: number;
-  readonly type: string;
-
-  text(): Promise<string>;
-  stream(): ReadableStream;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  json(): Promise<any>;
-  writer(params: { highWaterMark?: number }): FileSink;
-  exists(): Promise<boolean>;
-}
-
-export interface FileSink {
-  write(chunk: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer): number;
-  flush(): number | Promise<number>;
-  end(error?: Error): number | Promise<number>;
-  start(options?: { highWaterMark?: number }): void;
-  ref(): void;
-  unref(): void;
-}
-```

package/connectors/connect-yousign/node_modules/bun-types/docs/runtime/file-system-router.mdx

@@ -1,118 +0,0 @@
----
-title: File System Router
-description: Bun provides a fast API for resolving routes against file-system paths
----
-
-This API is primarily intended for library authors. At the moment only Next.js-style file-system routing is supported, but other styles may be added in the future.
-
-## Next.js-style
-
-The `FileSystemRouter` class can resolve routes against a `pages` directory. (The Next.js 13 `app` directory is not yet supported.) Consider the following `pages` directory:
-
-```txt
-pages
-├── index.tsx
-├── settings.tsx
-├── blog
-│   ├── [slug].tsx
-│   └── index.tsx
-└── [[...catchall]].tsx
-```
-
-The `FileSystemRouter` can be used to resolve routes against this directory:
-
-```ts router.ts
-const router = new Bun.FileSystemRouter({
-  style: "nextjs",
-  dir: "./pages",
-  origin: "https://mydomain.com",
-  assetPrefix: "_next/static/"
-});
-
-router.match("/");
-
-// =>
-{
-  filePath: "/path/to/pages/index.tsx",
-  kind: "exact",
-  name: "/",
-  pathname: "/",
-  src: "https://mydomain.com/_next/static/pages/index.tsx"
-}
-```
-
-Query parameters will be parsed and returned in the `query` property.
-
-```ts
-router.match("/settings?foo=bar");
-
-// =>
-{
-  filePath: "/Users/colinmcd94/Documents/bun/fun/pages/settings.tsx",
-  kind: "dynamic",
-  name: "/settings",
-  pathname: "/settings?foo=bar",
-  src: "https://mydomain.com/_next/static/pages/settings.tsx",
-  query: {
-    foo: "bar"
-  }
-}
-```
-
-The router will automatically parse URL parameters and return them in the `params` property:
-
-```ts
-router.match("/blog/my-cool-post");
-
-// =>
-{
-  filePath: "/Users/colinmcd94/Documents/bun/fun/pages/blog/[slug].tsx",
-  kind: "dynamic",
-  name: "/blog/[slug]",
-  pathname: "/blog/my-cool-post",
-  src: "https://mydomain.com/_next/static/pages/blog/[slug].tsx",
-  params: {
-    slug: "my-cool-post"
-  }
-}
-```
-
-The `.match()` method also accepts `Request` and `Response` objects. The `url` property will be used to resolve the route.
-
-```ts
-router.match(new Request("https://example.com/blog/my-cool-post"));
-```
-
-The router will read the directory contents on initialization. To re-scan the files, use the `.reload()` method.
-
-```ts
-router.reload();
-```
-
-## Reference
-
-```ts
-interface Bun {
-  class FileSystemRouter {
-    constructor(params: {
-      dir: string;
-      style: "nextjs";
-      origin?: string;
-      assetPrefix?: string;
-      fileExtensions?: string[];
-    });
-
-    reload(): void;
-
-    match(path: string | Request | Response): {
-      filePath: string;
-      kind: "exact" | "catch-all" | "optional-catch-all" | "dynamic";
-      name: string;
-      pathname: string;
-      src: string;
-      params?: Record<string, string>;
-      query?: Record<string, string>;
-    } | null
-  }
-}
-```