@hasna/connectors 1.3.24 → 1.3.25

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

@@ -1,223 +0,0 @@
----
-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

@@ -1,143 +0,0 @@
----
-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?