@hasna/connectors 1.3.0 → 1.3.2

package/connectors/connect-yousign/node_modules/bun-types/docs/project/bindgen.mdx

@@ -0,0 +1,223 @@
+---
+title: Bindgen
+description: Bindgen for Bun
+---
+
+<Note>This document is for maintainers and contributors to Bun, and describes internal implementation details.</Note>
+
+The new bindings generator, introduced to the codebase in Dec 2024, scans for
+`*.bind.ts` to find function and class definition, and generates glue code to
+interop between JavaScript and native code.
+
+There are currently other code generators and systems that achieve similar
+purposes. The following will all eventually be completely phased out in favor of
+this one:
+
+- "Classes generator", converting `*.classes.ts` for custom classes.
+- "JS2Native", allowing ad-hoc calls from `src/js` to native code.
+
+## Creating JS Functions in Zig
+
+Given a file implementing a simple function, such as `add`
+
+```zig src/bun.js/math.zig
+pub fn add(global: *jsc.JSGlobalObject, a: i32, b: i32) !i32 {
+    return std.math.add(i32, a, b) catch {
+        // Binding functions can return `error.OutOfMemory` and `error.JSError`.
+        // Others like `error.Overflow` from `std.math.add` must be converted.
+        // Remember to be descriptive.
+        return global.throwPretty("Integer overflow while adding", .{});
+    };
+}
+
+const gen = bun.gen.math; // "math" being this file's basename
+
+const std = @import("std");
+const bun = @import("bun");
+const jsc = bun.jsc;
+```
+
+Then describe the API schema using a `.bind.ts` function. The binding file goes next to the Zig file.
+
+```ts src/bun.js/math.bind.ts icon="/icons/typescript.svg"
+import { t, fn } from "bindgen";
+
+export const add = fn({
+  args: {
+    global: t.globalObject,
+    a: t.i32,
+    b: t.i32.default(1),
+  },
+  ret: t.i32,
+});
+```
+
+This function declaration is equivalent to:
+
+```ts
+/**
+ * Throws if zero arguments are provided.
+ * Wraps out of range numbers using modulo.
+ */
+declare function add(a: number, b: number = 1): number;
+```
+
+The code generator will provide `bun.gen.math.jsAdd`, which is the native
+function implementation. To pass to JavaScript, use
+`bun.gen.math.createAddCallback(global)`. JS files in `src/js/` may use
+`$bindgenFn("math.bind.ts", "add")` to get a handle to the implementation.
+
+## Strings
+
+The type for receiving strings is one of [`t.DOMString`](https://webidl.spec.whatwg.org/#idl-DOMString), [`t.ByteString`](https://webidl.spec.whatwg.org/#idl-ByteString), and [`t.USVString`](https://webidl.spec.whatwg.org/#idl-USVString). These map directly to their WebIDL counterparts, and have slightly different conversion logic. Bindgen will pass BunString to native code in all cases.
+
+When in doubt, use DOMString.
+
+`t.UTF8String` can be used in place of `t.DOMString`, but will call `bun.String.toUTF8`. The native callback gets `[]const u8` (WTF-8 data) passed to native code, freeing it after the function returns.
+
+TLDRs from WebIDL spec:
+
+- ByteString can only contain valid latin1 characters. It is not safe to assume bun.String is already in 8-bit format, but it is extremely likely.
+- USVString will not contain invalid surrogate pairs, aka text that can be represented correctly in UTF-8.
+- DOMString is the loosest but also most recommended strategy.
+
+## Function Variants
+
+A `variants` can specify multiple variants (also known as overloads).
+
+```ts src/bun.js/math.bind.ts icon="/icons/typescript.svg"
+import { t, fn } from "bindgen";
+
+export const action = fn({
+  variants: [
+    {
+      args: {
+        a: t.i32,
+      },
+      ret: t.i32,
+    },
+    {
+      args: {
+        a: t.DOMString,
+      },
+      ret: t.DOMString,
+    },
+  ],
+});
+```
+
+In Zig, each variant gets a number, based on the order the schema defines.
+
+```zig
+fn action1(a: i32) i32 {
+  return a;
+}
+
+fn action2(a: bun.String) bun.String {
+  return a;
+}
+```
+
+## `t.dictionary`
+
+A `dictionary` is a definition for a JavaScript object, typically as a function inputs. For function outputs, it is usually a smarter idea to declare a class type to add functions and destructuring.
+
+## Enumerations
+
+To use [WebIDL's enumeration](https://webidl.spec.whatwg.org/#idl-enums) type, use either:
+
+- `t.stringEnum`: Create and codegen a new enum type.
+- `t.zigEnum`: Derive a bindgen type off of an existing enum in the codebase.
+
+An example of `stringEnum` as used in `fmt.zig` / `bun:internal-for-testing`
+
+```ts
+export const Formatter = t.stringEnum("highlight-javascript", "escape-powershell");
+
+export const fmtString = fn({
+  args: {
+    global: t.globalObject,
+    code: t.UTF8String,
+    formatter: Formatter,
+  },
+  ret: t.DOMString,
+});
+```
+
+WebIDL strongly encourages using kebab case for enumeration values, to be consistent with existing Web APIs.
+
+### Deriving enums from Zig code
+
+TODO: zigEnum
+
+## `t.oneOf`
+
+A `oneOf` is a union between two or more types. It is represented by `union(enum)` in Zig.
+
+TODO:
+
+## Attributes
+
+There are set of attributes that can be chained onto `t.*` types. On all types there are:
+
+- `.required`, in dictionary parameters only
+- `.optional`, in function arguments only
+- `.default(T)`
+
+When a value is optional, it is lowered to a Zig optional.
+
+Depending on the type, there are more attributes available. See the type definitions in auto-complete for more details. Note that one of the above three can only be applied, and they must be applied at the end.
+
+### Integer Attributes
+
+Integer types allow customizing the overflow behavior with `clamp` or `enforceRange`
+
+```ts
+import { t, fn } from "bindgen";
+
+export const add = fn({
+  args: {
+    global: t.globalObject,
+    // enforce in i32 range
+    a: t.i32.enforceRange(),
+    // clamp to u16 range
+    b: t.u16,
+    // enforce in arbitrary range, with a default if not provided
+    c: t.i32.enforceRange(0, 1000).default(5),
+    // clamp to arbitrary range, or null
+    d: t.u16.clamp(0, 10).optional,
+  },
+  ret: t.i32,
+});
+```
+
+Various Node.js validator functions such as `validateInteger`, `validateNumber`, and more are available. Use these when implementing Node.js APIs, so the error messages match 1:1 what Node would do.
+
+Unlike `enforceRange`, which is taken from WebIDL, `validate*` functions are much more strict on the input they accept. For example, Node's numerical validator check `typeof value === 'number'`, while WebIDL uses `ToNumber` for lossy conversion.
+
+```ts
+import { t, fn } from "bindgen";
+
+export const add = fn({
+  args: {
+    global: t.globalObject,
+    // throw if not given a number
+    a: t.f64.validateNumber(),
+    // valid in i32 range
+    a: t.i32.validateInt32(),
+    // f64 within safe integer range
+    b: t.f64.validateInteger(),
+    // f64 in given range
+    c: t.f64.validateNumber(-10000, 10000),
+  },
+  ret: t.i32,
+});
+```
+
+## Callbacks
+
+TODO
+
+## Classes
+
+TODO

package/connectors/connect-yousign/node_modules/bun-types/docs/project/building-windows.mdx

@@ -0,0 +1,143 @@
+---
+title: Building Windows
+description: Building Bun on Windows
+---
+
+This document describes the build process for Windows. If you run into problems, please join the [#contributing channel on our Discord](http://bun.com/discord) for help.
+
+It is strongly recommended to use [PowerShell 7 (`pwsh.exe`)](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows?view=powershell-7.4) instead of the default `powershell.exe`.
+
+## Prerequisites
+
+### Enable Scripts
+
+By default, running unverified scripts are blocked.
+
+```ps1
+Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted
+```
+
+### System Dependencies
+
+Bun v1.1 or later. We use Bun to run it's own code generators.
+
+```ps1
+irm bun.sh/install.ps1 | iex
+```
+
+[Visual Studio](https://visualstudio.microsoft.com) with the "Desktop Development with C++" workload. While installing, make sure to install Git as well, if Git for Windows is not already installed.
+
+Visual Studio can be installed graphically using the wizard or through WinGet:
+
+```ps1
+winget install "Visual Studio Community 2022" --override "--add Microsoft.VisualStudio.Workload.NativeDesktop Microsoft.VisualStudio.Component.Git " -s msstore
+```
+
+After Visual Studio, you need the following:
+
+- LLVM 21.1.8
+- Go
+- Rust
+- NASM
+- Perl
+- Ruby
+- Node.js
+
+<Note>The Zig compiler is automatically downloaded, installed, and updated by the building process.</Note>
+
+[Scoop](https://scoop.sh) can be used to install these remaining tools easily.
+
+```ps1 Scoop (x64)
+irm https://get.scoop.sh | iex
+scoop install nodejs-lts go rust nasm ruby perl ccache
+# scoop seems to be buggy if you install llvm and the rest at the same time
+scoop install llvm@21.1.8
+```
+
+For Windows ARM64, download LLVM 21.1.8 directly from GitHub releases (first version with ARM64 Windows builds):
+
+```ps1 ARM64
+# Download and install LLVM for ARM64
+Invoke-WebRequest -Uri "https://github.com/llvm/llvm-project/releases/download/llvmorg-21.1.8/LLVM-21.1.8-woa64.exe" -OutFile "$env:TEMP\LLVM-21.1.8-woa64.exe"
+Start-Process -FilePath "$env:TEMP\LLVM-21.1.8-woa64.exe" -ArgumentList "/S" -Wait
+```
+
+<Note>
+  Please do not use WinGet/other package manager for these, as you will likely install Strawberry Perl instead of a more
+  minimal installation of Perl. Strawberry Perl includes many other utilities that get installed into `$Env:PATH` that
+  will conflict with MSVC and break the build.
+</Note>
+
+If you intend on building WebKit locally (optional, x64 only), you should install these packages:
+
+```ps1 Scoop
+scoop install make cygwin python
+```
+
+<Note>Cygwin is not required for ARM64 builds as WebKit is provided as a pre-built binary.</Note>
+
+From here on out, it is **expected you use a PowerShell Terminal with `.\scripts\vs-shell.ps1` sourced**. This script is available in the Bun repository and can be loaded by executing it:
+
+```ps1
+.\scripts\vs-shell.ps1
+```
+
+To verify, you can check for an MSVC-only command line such as `mt.exe`
+
+```ps1
+Get-Command mt
+```
+
+<Note>
+  It is not recommended to install `ninja` / `cmake` into your global path, because you may run into a situation where
+  you try to build bun without .\scripts\vs-shell.ps1 sourced.
+</Note>
+
+## Building
+
+```ps1
+bun run build
+
+# after the initial `bun run build` you can use the following to build
+ninja -Cbuild/debug
+```
+
+If this was successful, you should have a `bun-debug.exe` in the `build/debug` folder.
+
+```ps1
+.\build\debug\bun-debug.exe --revision
+```
+
+You should add this to `$Env:PATH`. The simplest way to do so is to open the start menu, type "Path", and then navigate the environment variables menu to add `C:\.....\bun\build\debug` to the user environment variable `PATH`. You should then restart your editor (if it does not update still, log out and log back in).
+
+## Extra paths
+
+- WebKit is extracted to `build/debug/cache/webkit/`
+- Zig is extracted to `build/debug/cache/zig/bin/zig.exe`
+
+## Tests
+
+You can run the test suite either using `bun test <path>` or by using the wrapper script `bun node:test <path>`. The `bun node:test` command runs every test file in a separate instance of bun.exe, to prevent a crash in the test runner from stopping the entire suite.
+
+```ps1
+# Setup
+bun i --cwd packages\bun-internal-test
+
+# Run the entire test suite with reporter
+# the package.json script "test" uses "build/debug/bun-debug.exe" by default
+bun run test
+
+# Run an individual test file:
+bun-debug test node\fs
+bun-debug test "C:\bun\test\js\bun\resolve\import-meta.test.js"
+```
+
+## Troubleshooting
+
+### .rc file fails to build
+
+`llvm-rc.exe` is odd. don't use it. use `rc.exe`, to do this make sure you are in a visual studio dev terminal, check `rc /?` to ensure it is `Microsoft Resource Compiler`
+
+### failed to write output 'bun-debug.exe': permission denied
+
+you cannot overwrite `bun-debug.exe` if it is already open. you likely have a running instance, maybe in the vscode debugger?