mirror of
https://github.com/oven-sh/bun
synced 2026-02-09 10:28:47 +00:00
aa0762e466
* Backport std::forward change * Implement `FormData` * Fix io_darwin headers issue * Implement `Blob` support in FormData * Add test for file upload * Fix bug with Blob not reading Content-Type * Finish implementing FormData * Add FormData to types --------- Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
3696 lines
191 KiB
Zig
3696 lines
191 KiB
Zig
/// Generated code! To regenerate, run:
|
|
///
|
|
/// make codegen
|
|
///
|
|
/// This file is generated by:
|
|
/// 1. `bun src/bun.js/scripts/generate-classes.ts`
|
|
/// 2. Scan for **/*.classes.ts files in src/bun.js/src
|
|
/// 3. Generate a JS wrapper for each class in:
|
|
/// - Zig: generated_classes.zig
|
|
/// - C++: ZigGeneratedClasses.h, ZigGeneratedClasses.cpp
|
|
/// 4. For the Zig code to successfully compile:
|
|
/// - Add it to generated_classes_list.zig
|
|
/// - pub usingnamespace JSC.Codegen.JSMyClassName;
|
|
/// 5. make clean-bindings && make bindings -j10
|
|
///
|
|
const JSC = @import("bun").JSC;
|
|
const Classes = @import("./generated_classes_list.zig").Classes;
|
|
const Environment = @import("../../env.zig");
|
|
const std = @import("std");
|
|
|
|
pub const StaticGetterType = fn (*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue) callconv(.C) JSC.JSValue;
|
|
pub const StaticSetterType = fn (*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue, JSC.JSValue) callconv(.C) bool;
|
|
pub const StaticCallbackType = fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
pub const JSBlob = struct {
|
|
const Blob = Classes.Blob;
|
|
const GetterType = fn (*Blob, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Blob, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Blob, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Blob, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Blob, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Blob {
|
|
JSC.markBinding(@src());
|
|
return Blob__fromJS(value);
|
|
}
|
|
|
|
/// Get the Blob constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Blob__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Blob
|
|
pub fn toJS(this: *Blob, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Blob__create(globalObject, this);
|
|
std.debug.assert(value__.as(Blob).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Blob__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Blob.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Blob) bool {
|
|
JSC.markBinding(@src());
|
|
return Blob__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Blob, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Blob__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Blob__fromJS(JSC.JSValue) ?*Blob;
|
|
extern fn Blob__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Blob__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Blob) JSC.JSValue;
|
|
|
|
extern fn Blob__dangerouslySetPtr(JSC.JSValue, ?*Blob) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Blob.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Blob)) {
|
|
@compileLog("Blob.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Blob.finalize) != (fn (*Blob) callconv(.C) void)) {
|
|
@compileLog("Blob.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Blob.getArrayBuffer) != CallbackType)
|
|
@compileLog("Expected Blob.getArrayBuffer to be a callback but received " ++ @typeName(@TypeOf(Blob.getArrayBuffer)));
|
|
if (@TypeOf(Blob.getFormData) != CallbackType)
|
|
@compileLog("Expected Blob.getFormData to be a callback but received " ++ @typeName(@TypeOf(Blob.getFormData)));
|
|
if (@TypeOf(Blob.getJSON) != CallbackType)
|
|
@compileLog("Expected Blob.getJSON to be a callback but received " ++ @typeName(@TypeOf(Blob.getJSON)));
|
|
if (@TypeOf(Blob.getSize) != GetterType)
|
|
@compileLog("Expected Blob.getSize to be a getter");
|
|
|
|
if (@TypeOf(Blob.getSlice) != CallbackType)
|
|
@compileLog("Expected Blob.getSlice to be a callback but received " ++ @typeName(@TypeOf(Blob.getSlice)));
|
|
if (@TypeOf(Blob.getStream) != CallbackType)
|
|
@compileLog("Expected Blob.getStream to be a callback but received " ++ @typeName(@TypeOf(Blob.getStream)));
|
|
if (@TypeOf(Blob.getText) != CallbackType)
|
|
@compileLog("Expected Blob.getText to be a callback but received " ++ @typeName(@TypeOf(Blob.getText)));
|
|
if (@TypeOf(Blob.getType) != GetterType)
|
|
@compileLog("Expected Blob.getType to be a getter");
|
|
|
|
if (@TypeOf(Blob.setType) != SetterType)
|
|
@compileLog("Expected Blob.setType to be a setter");
|
|
if (@TypeOf(Blob.getWriter) != CallbackType)
|
|
@compileLog("Expected Blob.getWriter to be a callback but received " ++ @typeName(@TypeOf(Blob.getWriter)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(Blob.constructor, .{ .name = "BlobClass__construct" });
|
|
@export(Blob.finalize, .{ .name = "BlobClass__finalize" });
|
|
@export(Blob.getArrayBuffer, .{ .name = "BlobPrototype__getArrayBuffer" });
|
|
@export(Blob.getFormData, .{ .name = "BlobPrototype__getFormData" });
|
|
@export(Blob.getJSON, .{ .name = "BlobPrototype__getJSON" });
|
|
@export(Blob.getSize, .{ .name = "BlobPrototype__getSize" });
|
|
@export(Blob.getSlice, .{ .name = "BlobPrototype__getSlice" });
|
|
@export(Blob.getStream, .{ .name = "BlobPrototype__getStream" });
|
|
@export(Blob.getText, .{ .name = "BlobPrototype__getText" });
|
|
@export(Blob.getType, .{ .name = "BlobPrototype__getType" });
|
|
@export(Blob.getWriter, .{ .name = "BlobPrototype__getWriter" });
|
|
@export(Blob.setType, .{ .name = "BlobPrototype__setType" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSCryptoHasher = struct {
|
|
const CryptoHasher = Classes.CryptoHasher;
|
|
const GetterType = fn (*CryptoHasher, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*CryptoHasher, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*CryptoHasher, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*CryptoHasher, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*CryptoHasher, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*CryptoHasher {
|
|
JSC.markBinding(@src());
|
|
return CryptoHasher__fromJS(value);
|
|
}
|
|
|
|
extern fn CryptoHasherPrototype__algorithmSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn CryptoHasherPrototype__algorithmGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `CryptoHasher.algorithm` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn algorithmSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
CryptoHasherPrototype__algorithmSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `CryptoHasher.algorithm` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn algorithmGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = CryptoHasherPrototype__algorithmGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the CryptoHasher constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return CryptoHasher__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of CryptoHasher
|
|
pub fn toJS(this: *CryptoHasher, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = CryptoHasher__create(globalObject, this);
|
|
std.debug.assert(value__.as(CryptoHasher).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return CryptoHasher__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of CryptoHasher.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*CryptoHasher) bool {
|
|
JSC.markBinding(@src());
|
|
return CryptoHasher__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *CryptoHasher, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(CryptoHasher__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn CryptoHasher__fromJS(JSC.JSValue) ?*CryptoHasher;
|
|
extern fn CryptoHasher__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn CryptoHasher__create(globalObject: *JSC.JSGlobalObject, ptr: ?*CryptoHasher) JSC.JSValue;
|
|
|
|
extern fn CryptoHasher__dangerouslySetPtr(JSC.JSValue, ?*CryptoHasher) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(CryptoHasher.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*CryptoHasher)) {
|
|
@compileLog("CryptoHasher.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(CryptoHasher.finalize) != (fn (*CryptoHasher) callconv(.C) void)) {
|
|
@compileLog("CryptoHasher.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(CryptoHasher.getAlgorithm) != GetterType)
|
|
@compileLog("Expected CryptoHasher.getAlgorithm to be a getter");
|
|
|
|
if (@TypeOf(CryptoHasher.getByteLength) != GetterType)
|
|
@compileLog("Expected CryptoHasher.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(CryptoHasher.digest) != CallbackType)
|
|
@compileLog("Expected CryptoHasher.digest to be a callback but received " ++ @typeName(@TypeOf(CryptoHasher.digest)));
|
|
if (@TypeOf(CryptoHasher.update) != CallbackType)
|
|
@compileLog("Expected CryptoHasher.update to be a callback but received " ++ @typeName(@TypeOf(CryptoHasher.update)));
|
|
if (@TypeOf(CryptoHasher.getAlgorithms) != StaticGetterType)
|
|
@compileLog("Expected CryptoHasher.getAlgorithms to be a static getter");
|
|
|
|
if (@TypeOf(CryptoHasher.hash) != StaticCallbackType)
|
|
@compileLog("Expected CryptoHasher.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(CryptoHasher.constructor, .{ .name = "CryptoHasherClass__construct" });
|
|
@export(CryptoHasher.digest, .{ .name = "CryptoHasherPrototype__digest" });
|
|
@export(CryptoHasher.finalize, .{ .name = "CryptoHasherClass__finalize" });
|
|
@export(CryptoHasher.getAlgorithm, .{ .name = "CryptoHasherPrototype__getAlgorithm" });
|
|
@export(CryptoHasher.getAlgorithms, .{ .name = "CryptoHasherClass__getAlgorithms" });
|
|
@export(CryptoHasher.getByteLength, .{ .name = "CryptoHasherPrototype__getByteLength" });
|
|
@export(CryptoHasher.hash, .{ .name = "CryptoHasherClass__hash" });
|
|
@export(CryptoHasher.update, .{ .name = "CryptoHasherPrototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSDirent = struct {
|
|
const Dirent = Classes.Dirent;
|
|
const GetterType = fn (*Dirent, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Dirent, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Dirent, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Dirent, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Dirent, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Dirent {
|
|
JSC.markBinding(@src());
|
|
return Dirent__fromJS(value);
|
|
}
|
|
|
|
extern fn DirentPrototype__nameSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn DirentPrototype__nameGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Dirent.name` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn nameSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
DirentPrototype__nameSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Dirent.name` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn nameGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = DirentPrototype__nameGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the Dirent constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Dirent__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Dirent
|
|
pub fn toJS(this: *Dirent, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Dirent__create(globalObject, this);
|
|
std.debug.assert(value__.as(Dirent).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Dirent__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Dirent.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Dirent) bool {
|
|
JSC.markBinding(@src());
|
|
return Dirent__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Dirent, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Dirent__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Dirent__fromJS(JSC.JSValue) ?*Dirent;
|
|
extern fn Dirent__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Dirent__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Dirent) JSC.JSValue;
|
|
|
|
extern fn Dirent__dangerouslySetPtr(JSC.JSValue, ?*Dirent) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Dirent.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Dirent)) {
|
|
@compileLog("Dirent.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Dirent.finalize) != (fn (*Dirent) callconv(.C) void)) {
|
|
@compileLog("Dirent.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Dirent.isBlockDevice) != CallbackType)
|
|
@compileLog("Expected Dirent.isBlockDevice to be a callback but received " ++ @typeName(@TypeOf(Dirent.isBlockDevice)));
|
|
if (@TypeOf(Dirent.isCharacterDevice) != CallbackType)
|
|
@compileLog("Expected Dirent.isCharacterDevice to be a callback but received " ++ @typeName(@TypeOf(Dirent.isCharacterDevice)));
|
|
if (@TypeOf(Dirent.isDirectory) != CallbackType)
|
|
@compileLog("Expected Dirent.isDirectory to be a callback but received " ++ @typeName(@TypeOf(Dirent.isDirectory)));
|
|
if (@TypeOf(Dirent.isFIFO) != CallbackType)
|
|
@compileLog("Expected Dirent.isFIFO to be a callback but received " ++ @typeName(@TypeOf(Dirent.isFIFO)));
|
|
if (@TypeOf(Dirent.isFile) != CallbackType)
|
|
@compileLog("Expected Dirent.isFile to be a callback but received " ++ @typeName(@TypeOf(Dirent.isFile)));
|
|
if (@TypeOf(Dirent.isSocket) != CallbackType)
|
|
@compileLog("Expected Dirent.isSocket to be a callback but received " ++ @typeName(@TypeOf(Dirent.isSocket)));
|
|
if (@TypeOf(Dirent.isSymbolicLink) != CallbackType)
|
|
@compileLog("Expected Dirent.isSymbolicLink to be a callback but received " ++ @typeName(@TypeOf(Dirent.isSymbolicLink)));
|
|
if (@TypeOf(Dirent.getName) != GetterType)
|
|
@compileLog("Expected Dirent.getName to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(Dirent.constructor, .{ .name = "DirentClass__construct" });
|
|
@export(Dirent.finalize, .{ .name = "DirentClass__finalize" });
|
|
@export(Dirent.getName, .{ .name = "DirentPrototype__getName" });
|
|
@export(Dirent.isBlockDevice, .{ .name = "DirentPrototype__isBlockDevice" });
|
|
@export(Dirent.isCharacterDevice, .{ .name = "DirentPrototype__isCharacterDevice" });
|
|
@export(Dirent.isDirectory, .{ .name = "DirentPrototype__isDirectory" });
|
|
@export(Dirent.isFIFO, .{ .name = "DirentPrototype__isFIFO" });
|
|
@export(Dirent.isFile, .{ .name = "DirentPrototype__isFile" });
|
|
@export(Dirent.isSocket, .{ .name = "DirentPrototype__isSocket" });
|
|
@export(Dirent.isSymbolicLink, .{ .name = "DirentPrototype__isSymbolicLink" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSExpect = struct {
|
|
const Expect = Classes.Expect;
|
|
const GetterType = fn (*Expect, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Expect, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Expect, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Expect, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Expect, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Expect {
|
|
JSC.markBinding(@src());
|
|
return Expect__fromJS(value);
|
|
}
|
|
|
|
extern fn ExpectPrototype__capturedValueSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ExpectPrototype__capturedValueGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Expect.capturedValue` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn capturedValueSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ExpectPrototype__capturedValueSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Expect.capturedValue` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn capturedValueGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ExpectPrototype__capturedValueGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ExpectPrototype__resultValueSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ExpectPrototype__resultValueGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Expect.resultValue` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn resultValueSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ExpectPrototype__resultValueSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Expect.resultValue` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn resultValueGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ExpectPrototype__resultValueGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the Expect constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Expect__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Expect
|
|
pub fn toJS(this: *Expect, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Expect__create(globalObject, this);
|
|
std.debug.assert(value__.as(Expect).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Expect__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Expect.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Expect) bool {
|
|
JSC.markBinding(@src());
|
|
return Expect__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Expect, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Expect__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Expect__fromJS(JSC.JSValue) ?*Expect;
|
|
extern fn Expect__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Expect__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Expect) JSC.JSValue;
|
|
|
|
extern fn Expect__dangerouslySetPtr(JSC.JSValue, ?*Expect) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Expect.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Expect)) {
|
|
@compileLog("Expect.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Expect.finalize) != (fn (*Expect) callconv(.C) void)) {
|
|
@compileLog("Expect.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Expect.getNot) != GetterTypeWithThisValue)
|
|
@compileLog("Expected Expect.getNot to be a getter with thisValue");
|
|
if (@TypeOf(Expect.getRejects) != GetterTypeWithThisValue)
|
|
@compileLog("Expected Expect.getRejects to be a getter with thisValue");
|
|
if (@TypeOf(Expect.getResolves) != GetterTypeWithThisValue)
|
|
@compileLog("Expected Expect.getResolves to be a getter with thisValue");
|
|
if (@TypeOf(Expect.toBe) != CallbackType)
|
|
@compileLog("Expected Expect.toBe to be a callback but received " ++ @typeName(@TypeOf(Expect.toBe)));
|
|
if (@TypeOf(Expect.toBeCloseTo) != CallbackType)
|
|
@compileLog("Expected Expect.toBeCloseTo to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeCloseTo)));
|
|
if (@TypeOf(Expect.toBeDefined) != CallbackType)
|
|
@compileLog("Expected Expect.toBeDefined to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeDefined)));
|
|
if (@TypeOf(Expect.toBeFalsy) != CallbackType)
|
|
@compileLog("Expected Expect.toBeFalsy to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeFalsy)));
|
|
if (@TypeOf(Expect.toBeGreaterThan) != CallbackType)
|
|
@compileLog("Expected Expect.toBeGreaterThan to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeGreaterThan)));
|
|
if (@TypeOf(Expect.toBeGreaterThanOrEqual) != CallbackType)
|
|
@compileLog("Expected Expect.toBeGreaterThanOrEqual to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeGreaterThanOrEqual)));
|
|
if (@TypeOf(Expect.toBeInstanceOf) != CallbackType)
|
|
@compileLog("Expected Expect.toBeInstanceOf to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeInstanceOf)));
|
|
if (@TypeOf(Expect.toBeLessThan) != CallbackType)
|
|
@compileLog("Expected Expect.toBeLessThan to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeLessThan)));
|
|
if (@TypeOf(Expect.toBeLessThanOrEqual) != CallbackType)
|
|
@compileLog("Expected Expect.toBeLessThanOrEqual to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeLessThanOrEqual)));
|
|
if (@TypeOf(Expect.toBeNaN) != CallbackType)
|
|
@compileLog("Expected Expect.toBeNaN to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeNaN)));
|
|
if (@TypeOf(Expect.toBeNull) != CallbackType)
|
|
@compileLog("Expected Expect.toBeNull to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeNull)));
|
|
if (@TypeOf(Expect.toBeTruthy) != CallbackType)
|
|
@compileLog("Expected Expect.toBeTruthy to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeTruthy)));
|
|
if (@TypeOf(Expect.toBeUndefined) != CallbackType)
|
|
@compileLog("Expected Expect.toBeUndefined to be a callback but received " ++ @typeName(@TypeOf(Expect.toBeUndefined)));
|
|
if (@TypeOf(Expect.toContain) != CallbackType)
|
|
@compileLog("Expected Expect.toContain to be a callback but received " ++ @typeName(@TypeOf(Expect.toContain)));
|
|
if (@TypeOf(Expect.toContainEqual) != CallbackType)
|
|
@compileLog("Expected Expect.toContainEqual to be a callback but received " ++ @typeName(@TypeOf(Expect.toContainEqual)));
|
|
if (@TypeOf(Expect.toEqual) != CallbackType)
|
|
@compileLog("Expected Expect.toEqual to be a callback but received " ++ @typeName(@TypeOf(Expect.toEqual)));
|
|
if (@TypeOf(Expect.toHaveBeenCalledTimes) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveBeenCalledTimes to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveBeenCalledTimes)));
|
|
if (@TypeOf(Expect.toHaveBeenCalledWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveBeenCalledWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveBeenCalledWith)));
|
|
if (@TypeOf(Expect.toHaveBeenLastCalledWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveBeenLastCalledWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveBeenLastCalledWith)));
|
|
if (@TypeOf(Expect.toHaveBeenNthCalledWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveBeenNthCalledWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveBeenNthCalledWith)));
|
|
if (@TypeOf(Expect.toHaveLastReturnedWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveLastReturnedWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveLastReturnedWith)));
|
|
if (@TypeOf(Expect.toHaveLength) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveLength to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveLength)));
|
|
if (@TypeOf(Expect.toHaveNthReturnedWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveNthReturnedWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveNthReturnedWith)));
|
|
if (@TypeOf(Expect.toHaveProperty) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveProperty to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveProperty)));
|
|
if (@TypeOf(Expect.toHaveReturnedTimes) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveReturnedTimes to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveReturnedTimes)));
|
|
if (@TypeOf(Expect.toHaveReturnedWith) != CallbackType)
|
|
@compileLog("Expected Expect.toHaveReturnedWith to be a callback but received " ++ @typeName(@TypeOf(Expect.toHaveReturnedWith)));
|
|
if (@TypeOf(Expect.toMatch) != CallbackType)
|
|
@compileLog("Expected Expect.toMatch to be a callback but received " ++ @typeName(@TypeOf(Expect.toMatch)));
|
|
if (@TypeOf(Expect.toMatchInlineSnapshot) != CallbackType)
|
|
@compileLog("Expected Expect.toMatchInlineSnapshot to be a callback but received " ++ @typeName(@TypeOf(Expect.toMatchInlineSnapshot)));
|
|
if (@TypeOf(Expect.toMatchObject) != CallbackType)
|
|
@compileLog("Expected Expect.toMatchObject to be a callback but received " ++ @typeName(@TypeOf(Expect.toMatchObject)));
|
|
if (@TypeOf(Expect.toMatchSnapshot) != CallbackType)
|
|
@compileLog("Expected Expect.toMatchSnapshot to be a callback but received " ++ @typeName(@TypeOf(Expect.toMatchSnapshot)));
|
|
if (@TypeOf(Expect.toStrictEqual) != CallbackType)
|
|
@compileLog("Expected Expect.toStrictEqual to be a callback but received " ++ @typeName(@TypeOf(Expect.toStrictEqual)));
|
|
if (@TypeOf(Expect.toThrow) != CallbackType)
|
|
@compileLog("Expected Expect.toThrow to be a callback but received " ++ @typeName(@TypeOf(Expect.toThrow)));
|
|
if (@TypeOf(Expect.toThrowErrorMatchingInlineSnapshot) != CallbackType)
|
|
@compileLog("Expected Expect.toThrowErrorMatchingInlineSnapshot to be a callback but received " ++ @typeName(@TypeOf(Expect.toThrowErrorMatchingInlineSnapshot)));
|
|
if (@TypeOf(Expect.toThrowErrorMatchingSnapshot) != CallbackType)
|
|
@compileLog("Expected Expect.toThrowErrorMatchingSnapshot to be a callback but received " ++ @typeName(@TypeOf(Expect.toThrowErrorMatchingSnapshot)));
|
|
if (@TypeOf(Expect.addSnapshotSerializer) != StaticCallbackType)
|
|
@compileLog("Expected Expect.addSnapshotSerializer to be a static callback");
|
|
if (@TypeOf(Expect.any) != StaticCallbackType)
|
|
@compileLog("Expected Expect.any to be a static callback");
|
|
if (@TypeOf(Expect.anything) != StaticCallbackType)
|
|
@compileLog("Expected Expect.anything to be a static callback");
|
|
if (@TypeOf(Expect.arrayContaining) != StaticCallbackType)
|
|
@compileLog("Expected Expect.arrayContaining to be a static callback");
|
|
if (@TypeOf(Expect.assertions) != StaticCallbackType)
|
|
@compileLog("Expected Expect.assertions to be a static callback");
|
|
if (@TypeOf(Expect.extend) != StaticCallbackType)
|
|
@compileLog("Expected Expect.extend to be a static callback");
|
|
if (@TypeOf(Expect.hasAssertions) != StaticCallbackType)
|
|
@compileLog("Expected Expect.hasAssertions to be a static callback");
|
|
if (@TypeOf(Expect.getStaticNot) != StaticGetterType)
|
|
@compileLog("Expected Expect.getStaticNot to be a static getter");
|
|
|
|
if (@TypeOf(Expect.objectContaining) != StaticCallbackType)
|
|
@compileLog("Expected Expect.objectContaining to be a static callback");
|
|
if (@TypeOf(Expect.getStaticRejects) != StaticGetterType)
|
|
@compileLog("Expected Expect.getStaticRejects to be a static getter");
|
|
|
|
if (@TypeOf(Expect.getStaticResolves) != StaticGetterType)
|
|
@compileLog("Expected Expect.getStaticResolves to be a static getter");
|
|
|
|
if (@TypeOf(Expect.stringContaining) != StaticCallbackType)
|
|
@compileLog("Expected Expect.stringContaining to be a static callback");
|
|
if (@TypeOf(Expect.stringMatching) != StaticCallbackType)
|
|
@compileLog("Expected Expect.stringMatching to be a static callback");
|
|
if (@TypeOf(Expect.call) != StaticCallbackType)
|
|
@compileLog("Expected Expect.call to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(Expect.addSnapshotSerializer, .{ .name = "ExpectClass__addSnapshotSerializer" });
|
|
@export(Expect.any, .{ .name = "ExpectClass__any" });
|
|
@export(Expect.anything, .{ .name = "ExpectClass__anything" });
|
|
@export(Expect.arrayContaining, .{ .name = "ExpectClass__arrayContaining" });
|
|
@export(Expect.assertions, .{ .name = "ExpectClass__assertions" });
|
|
@export(Expect.call, .{ .name = "ExpectClass__call" });
|
|
@export(Expect.constructor, .{ .name = "ExpectClass__construct" });
|
|
@export(Expect.extend, .{ .name = "ExpectClass__extend" });
|
|
@export(Expect.finalize, .{ .name = "ExpectClass__finalize" });
|
|
@export(Expect.getNot, .{ .name = "ExpectPrototype__getNot" });
|
|
@export(Expect.getRejects, .{ .name = "ExpectPrototype__getRejects" });
|
|
@export(Expect.getResolves, .{ .name = "ExpectPrototype__getResolves" });
|
|
@export(Expect.getStaticNot, .{ .name = "ExpectClass__getStaticNot" });
|
|
@export(Expect.getStaticRejects, .{ .name = "ExpectClass__getStaticRejects" });
|
|
@export(Expect.getStaticResolves, .{ .name = "ExpectClass__getStaticResolves" });
|
|
@export(Expect.hasAssertions, .{ .name = "ExpectClass__hasAssertions" });
|
|
@export(Expect.objectContaining, .{ .name = "ExpectClass__objectContaining" });
|
|
@export(Expect.stringContaining, .{ .name = "ExpectClass__stringContaining" });
|
|
@export(Expect.stringMatching, .{ .name = "ExpectClass__stringMatching" });
|
|
@export(Expect.toBe, .{ .name = "ExpectPrototype__toBe" });
|
|
@export(Expect.toBeCloseTo, .{ .name = "ExpectPrototype__toBeCloseTo" });
|
|
@export(Expect.toBeDefined, .{ .name = "ExpectPrototype__toBeDefined" });
|
|
@export(Expect.toBeFalsy, .{ .name = "ExpectPrototype__toBeFalsy" });
|
|
@export(Expect.toBeGreaterThan, .{ .name = "ExpectPrototype__toBeGreaterThan" });
|
|
@export(Expect.toBeGreaterThanOrEqual, .{ .name = "ExpectPrototype__toBeGreaterThanOrEqual" });
|
|
@export(Expect.toBeInstanceOf, .{ .name = "ExpectPrototype__toBeInstanceOf" });
|
|
@export(Expect.toBeLessThan, .{ .name = "ExpectPrototype__toBeLessThan" });
|
|
@export(Expect.toBeLessThanOrEqual, .{ .name = "ExpectPrototype__toBeLessThanOrEqual" });
|
|
@export(Expect.toBeNaN, .{ .name = "ExpectPrototype__toBeNaN" });
|
|
@export(Expect.toBeNull, .{ .name = "ExpectPrototype__toBeNull" });
|
|
@export(Expect.toBeTruthy, .{ .name = "ExpectPrototype__toBeTruthy" });
|
|
@export(Expect.toBeUndefined, .{ .name = "ExpectPrototype__toBeUndefined" });
|
|
@export(Expect.toContain, .{ .name = "ExpectPrototype__toContain" });
|
|
@export(Expect.toContainEqual, .{ .name = "ExpectPrototype__toContainEqual" });
|
|
@export(Expect.toEqual, .{ .name = "ExpectPrototype__toEqual" });
|
|
@export(Expect.toHaveBeenCalledTimes, .{ .name = "ExpectPrototype__toHaveBeenCalledTimes" });
|
|
@export(Expect.toHaveBeenCalledWith, .{ .name = "ExpectPrototype__toHaveBeenCalledWith" });
|
|
@export(Expect.toHaveBeenLastCalledWith, .{ .name = "ExpectPrototype__toHaveBeenLastCalledWith" });
|
|
@export(Expect.toHaveBeenNthCalledWith, .{ .name = "ExpectPrototype__toHaveBeenNthCalledWith" });
|
|
@export(Expect.toHaveLastReturnedWith, .{ .name = "ExpectPrototype__toHaveLastReturnedWith" });
|
|
@export(Expect.toHaveLength, .{ .name = "ExpectPrototype__toHaveLength" });
|
|
@export(Expect.toHaveNthReturnedWith, .{ .name = "ExpectPrototype__toHaveNthReturnedWith" });
|
|
@export(Expect.toHaveProperty, .{ .name = "ExpectPrototype__toHaveProperty" });
|
|
@export(Expect.toHaveReturnedTimes, .{ .name = "ExpectPrototype__toHaveReturnedTimes" });
|
|
@export(Expect.toHaveReturnedWith, .{ .name = "ExpectPrototype__toHaveReturnedWith" });
|
|
@export(Expect.toMatch, .{ .name = "ExpectPrototype__toMatch" });
|
|
@export(Expect.toMatchInlineSnapshot, .{ .name = "ExpectPrototype__toMatchInlineSnapshot" });
|
|
@export(Expect.toMatchObject, .{ .name = "ExpectPrototype__toMatchObject" });
|
|
@export(Expect.toMatchSnapshot, .{ .name = "ExpectPrototype__toMatchSnapshot" });
|
|
@export(Expect.toStrictEqual, .{ .name = "ExpectPrototype__toStrictEqual" });
|
|
@export(Expect.toThrow, .{ .name = "ExpectPrototype__toThrow" });
|
|
@export(Expect.toThrowErrorMatchingInlineSnapshot, .{ .name = "ExpectPrototype__toThrowErrorMatchingInlineSnapshot" });
|
|
@export(Expect.toThrowErrorMatchingSnapshot, .{ .name = "ExpectPrototype__toThrowErrorMatchingSnapshot" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSFileSystemRouter = struct {
|
|
const FileSystemRouter = Classes.FileSystemRouter;
|
|
const GetterType = fn (*FileSystemRouter, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*FileSystemRouter, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*FileSystemRouter, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*FileSystemRouter, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*FileSystemRouter, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*FileSystemRouter {
|
|
JSC.markBinding(@src());
|
|
return FileSystemRouter__fromJS(value);
|
|
}
|
|
|
|
extern fn FileSystemRouterPrototype__originSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn FileSystemRouterPrototype__originGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `FileSystemRouter.origin` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn originSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
FileSystemRouterPrototype__originSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `FileSystemRouter.origin` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn originGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = FileSystemRouterPrototype__originGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn FileSystemRouterPrototype__routesSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn FileSystemRouterPrototype__routesGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `FileSystemRouter.routes` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn routesSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
FileSystemRouterPrototype__routesSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `FileSystemRouter.routes` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn routesGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = FileSystemRouterPrototype__routesGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn FileSystemRouterPrototype__styleSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn FileSystemRouterPrototype__styleGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `FileSystemRouter.style` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn styleSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
FileSystemRouterPrototype__styleSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `FileSystemRouter.style` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn styleGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = FileSystemRouterPrototype__styleGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the FileSystemRouter constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return FileSystemRouter__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of FileSystemRouter
|
|
pub fn toJS(this: *FileSystemRouter, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = FileSystemRouter__create(globalObject, this);
|
|
std.debug.assert(value__.as(FileSystemRouter).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return FileSystemRouter__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of FileSystemRouter.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*FileSystemRouter) bool {
|
|
JSC.markBinding(@src());
|
|
return FileSystemRouter__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *FileSystemRouter, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(FileSystemRouter__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn FileSystemRouter__fromJS(JSC.JSValue) ?*FileSystemRouter;
|
|
extern fn FileSystemRouter__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn FileSystemRouter__create(globalObject: *JSC.JSGlobalObject, ptr: ?*FileSystemRouter) JSC.JSValue;
|
|
|
|
extern fn FileSystemRouter__dangerouslySetPtr(JSC.JSValue, ?*FileSystemRouter) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(FileSystemRouter.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*FileSystemRouter)) {
|
|
@compileLog("FileSystemRouter.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(FileSystemRouter.finalize) != (fn (*FileSystemRouter) callconv(.C) void)) {
|
|
@compileLog("FileSystemRouter.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(FileSystemRouter.match) != CallbackType)
|
|
@compileLog("Expected FileSystemRouter.match to be a callback but received " ++ @typeName(@TypeOf(FileSystemRouter.match)));
|
|
if (@TypeOf(FileSystemRouter.getOrigin) != GetterType)
|
|
@compileLog("Expected FileSystemRouter.getOrigin to be a getter");
|
|
|
|
if (@TypeOf(FileSystemRouter.reload) != CallbackType)
|
|
@compileLog("Expected FileSystemRouter.reload to be a callback but received " ++ @typeName(@TypeOf(FileSystemRouter.reload)));
|
|
if (@TypeOf(FileSystemRouter.getRoutes) != GetterType)
|
|
@compileLog("Expected FileSystemRouter.getRoutes to be a getter");
|
|
|
|
if (@TypeOf(FileSystemRouter.getStyle) != GetterType)
|
|
@compileLog("Expected FileSystemRouter.getStyle to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(FileSystemRouter.constructor, .{ .name = "FileSystemRouterClass__construct" });
|
|
@export(FileSystemRouter.finalize, .{ .name = "FileSystemRouterClass__finalize" });
|
|
@export(FileSystemRouter.getOrigin, .{ .name = "FileSystemRouterPrototype__getOrigin" });
|
|
@export(FileSystemRouter.getRoutes, .{ .name = "FileSystemRouterPrototype__getRoutes" });
|
|
@export(FileSystemRouter.getStyle, .{ .name = "FileSystemRouterPrototype__getStyle" });
|
|
@export(FileSystemRouter.match, .{ .name = "FileSystemRouterPrototype__match" });
|
|
@export(FileSystemRouter.reload, .{ .name = "FileSystemRouterPrototype__reload" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSListener = struct {
|
|
const Listener = Classes.Listener;
|
|
const GetterType = fn (*Listener, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Listener, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Listener, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Listener, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Listener, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Listener {
|
|
JSC.markBinding(@src());
|
|
return Listener__fromJS(value);
|
|
}
|
|
|
|
extern fn ListenerPrototype__hostnameSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ListenerPrototype__hostnameGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Listener.hostname` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn hostnameSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ListenerPrototype__hostnameSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Listener.hostname` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn hostnameGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ListenerPrototype__hostnameGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ListenerPrototype__unixSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ListenerPrototype__unixGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Listener.unix` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn unixSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ListenerPrototype__unixSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Listener.unix` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn unixGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ListenerPrototype__unixGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Create a new instance of Listener
|
|
pub fn toJS(this: *Listener, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Listener__create(globalObject, this);
|
|
std.debug.assert(value__.as(Listener).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Listener__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Listener.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Listener) bool {
|
|
JSC.markBinding(@src());
|
|
return Listener__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Listener, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Listener__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Listener__fromJS(JSC.JSValue) ?*Listener;
|
|
extern fn Listener__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Listener__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Listener) JSC.JSValue;
|
|
|
|
extern fn Listener__dangerouslySetPtr(JSC.JSValue, ?*Listener) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Listener.finalize) != (fn (*Listener) callconv(.C) void)) {
|
|
@compileLog("Listener.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Listener.getData) != GetterType)
|
|
@compileLog("Expected Listener.getData to be a getter");
|
|
|
|
if (@TypeOf(Listener.setData) != SetterType)
|
|
@compileLog("Expected Listener.setData to be a setter");
|
|
if (@TypeOf(Listener.getHostname) != GetterType)
|
|
@compileLog("Expected Listener.getHostname to be a getter");
|
|
|
|
if (@TypeOf(Listener.getPort) != GetterType)
|
|
@compileLog("Expected Listener.getPort to be a getter");
|
|
|
|
if (@TypeOf(Listener.ref) != CallbackType)
|
|
@compileLog("Expected Listener.ref to be a callback but received " ++ @typeName(@TypeOf(Listener.ref)));
|
|
if (@TypeOf(Listener.reload) != CallbackType)
|
|
@compileLog("Expected Listener.reload to be a callback but received " ++ @typeName(@TypeOf(Listener.reload)));
|
|
if (@TypeOf(Listener.stop) != CallbackType)
|
|
@compileLog("Expected Listener.stop to be a callback but received " ++ @typeName(@TypeOf(Listener.stop)));
|
|
if (@TypeOf(Listener.getUnix) != GetterType)
|
|
@compileLog("Expected Listener.getUnix to be a getter");
|
|
|
|
if (@TypeOf(Listener.unref) != CallbackType)
|
|
@compileLog("Expected Listener.unref to be a callback but received " ++ @typeName(@TypeOf(Listener.unref)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(Listener.finalize, .{ .name = "ListenerClass__finalize" });
|
|
@export(Listener.getData, .{ .name = "ListenerPrototype__getData" });
|
|
@export(Listener.getHostname, .{ .name = "ListenerPrototype__getHostname" });
|
|
@export(Listener.getPort, .{ .name = "ListenerPrototype__getPort" });
|
|
@export(Listener.getUnix, .{ .name = "ListenerPrototype__getUnix" });
|
|
@export(Listener.ref, .{ .name = "ListenerPrototype__ref" });
|
|
@export(Listener.reload, .{ .name = "ListenerPrototype__reload" });
|
|
@export(Listener.setData, .{ .name = "ListenerPrototype__setData" });
|
|
@export(Listener.stop, .{ .name = "ListenerPrototype__stop" });
|
|
@export(Listener.unref, .{ .name = "ListenerPrototype__unref" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSMD4 = struct {
|
|
const MD4 = Classes.MD4;
|
|
const GetterType = fn (*MD4, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*MD4, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*MD4, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*MD4, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*MD4, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*MD4 {
|
|
JSC.markBinding(@src());
|
|
return MD4__fromJS(value);
|
|
}
|
|
|
|
/// Get the MD4 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return MD4__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of MD4
|
|
pub fn toJS(this: *MD4, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = MD4__create(globalObject, this);
|
|
std.debug.assert(value__.as(MD4).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return MD4__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of MD4.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*MD4) bool {
|
|
JSC.markBinding(@src());
|
|
return MD4__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *MD4, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(MD4__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn MD4__fromJS(JSC.JSValue) ?*MD4;
|
|
extern fn MD4__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn MD4__create(globalObject: *JSC.JSGlobalObject, ptr: ?*MD4) JSC.JSValue;
|
|
|
|
extern fn MD4__dangerouslySetPtr(JSC.JSValue, ?*MD4) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(MD4.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*MD4)) {
|
|
@compileLog("MD4.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(MD4.finalize) != (fn (*MD4) callconv(.C) void)) {
|
|
@compileLog("MD4.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(MD4.getByteLength) != GetterType)
|
|
@compileLog("Expected MD4.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(MD4.digest) != CallbackType)
|
|
@compileLog("Expected MD4.digest to be a callback but received " ++ @typeName(@TypeOf(MD4.digest)));
|
|
if (@TypeOf(MD4.update) != CallbackType)
|
|
@compileLog("Expected MD4.update to be a callback but received " ++ @typeName(@TypeOf(MD4.update)));
|
|
if (@TypeOf(MD4.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected MD4.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(MD4.hash) != StaticCallbackType)
|
|
@compileLog("Expected MD4.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(MD4.constructor, .{ .name = "MD4Class__construct" });
|
|
@export(MD4.digest, .{ .name = "MD4Prototype__digest" });
|
|
@export(MD4.finalize, .{ .name = "MD4Class__finalize" });
|
|
@export(MD4.getByteLength, .{ .name = "MD4Prototype__getByteLength" });
|
|
@export(MD4.getByteLengthStatic, .{ .name = "MD4Class__getByteLengthStatic" });
|
|
@export(MD4.hash, .{ .name = "MD4Class__hash" });
|
|
@export(MD4.update, .{ .name = "MD4Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSMD5 = struct {
|
|
const MD5 = Classes.MD5;
|
|
const GetterType = fn (*MD5, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*MD5, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*MD5, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*MD5, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*MD5, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*MD5 {
|
|
JSC.markBinding(@src());
|
|
return MD5__fromJS(value);
|
|
}
|
|
|
|
/// Get the MD5 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return MD5__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of MD5
|
|
pub fn toJS(this: *MD5, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = MD5__create(globalObject, this);
|
|
std.debug.assert(value__.as(MD5).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return MD5__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of MD5.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*MD5) bool {
|
|
JSC.markBinding(@src());
|
|
return MD5__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *MD5, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(MD5__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn MD5__fromJS(JSC.JSValue) ?*MD5;
|
|
extern fn MD5__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn MD5__create(globalObject: *JSC.JSGlobalObject, ptr: ?*MD5) JSC.JSValue;
|
|
|
|
extern fn MD5__dangerouslySetPtr(JSC.JSValue, ?*MD5) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(MD5.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*MD5)) {
|
|
@compileLog("MD5.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(MD5.finalize) != (fn (*MD5) callconv(.C) void)) {
|
|
@compileLog("MD5.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(MD5.getByteLength) != GetterType)
|
|
@compileLog("Expected MD5.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(MD5.digest) != CallbackType)
|
|
@compileLog("Expected MD5.digest to be a callback but received " ++ @typeName(@TypeOf(MD5.digest)));
|
|
if (@TypeOf(MD5.update) != CallbackType)
|
|
@compileLog("Expected MD5.update to be a callback but received " ++ @typeName(@TypeOf(MD5.update)));
|
|
if (@TypeOf(MD5.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected MD5.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(MD5.hash) != StaticCallbackType)
|
|
@compileLog("Expected MD5.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(MD5.constructor, .{ .name = "MD5Class__construct" });
|
|
@export(MD5.digest, .{ .name = "MD5Prototype__digest" });
|
|
@export(MD5.finalize, .{ .name = "MD5Class__finalize" });
|
|
@export(MD5.getByteLength, .{ .name = "MD5Prototype__getByteLength" });
|
|
@export(MD5.getByteLengthStatic, .{ .name = "MD5Class__getByteLengthStatic" });
|
|
@export(MD5.hash, .{ .name = "MD5Class__hash" });
|
|
@export(MD5.update, .{ .name = "MD5Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSMatchedRoute = struct {
|
|
const MatchedRoute = Classes.MatchedRoute;
|
|
const GetterType = fn (*MatchedRoute, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*MatchedRoute, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*MatchedRoute, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*MatchedRoute, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*MatchedRoute, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*MatchedRoute {
|
|
JSC.markBinding(@src());
|
|
return MatchedRoute__fromJS(value);
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__filePathSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__filePathGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.filePath` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn filePathSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__filePathSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.filePath` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn filePathGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__filePathGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__kindSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__kindGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.kind` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn kindSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__kindSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.kind` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn kindGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__kindGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__nameSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__nameGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.name` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn nameSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__nameSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.name` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn nameGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__nameGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__paramsSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__paramsGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.params` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn paramsSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__paramsSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.params` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn paramsGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__paramsGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__pathnameSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__pathnameGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.pathname` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn pathnameSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__pathnameSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.pathname` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn pathnameGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__pathnameGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__querySetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__queryGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.query` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn querySetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__querySetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.query` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn queryGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__queryGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn MatchedRoutePrototype__scriptSrcSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn MatchedRoutePrototype__scriptSrcGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `MatchedRoute.scriptSrc` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn scriptSrcSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
MatchedRoutePrototype__scriptSrcSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `MatchedRoute.scriptSrc` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn scriptSrcGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = MatchedRoutePrototype__scriptSrcGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Create a new instance of MatchedRoute
|
|
pub fn toJS(this: *MatchedRoute, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = MatchedRoute__create(globalObject, this);
|
|
std.debug.assert(value__.as(MatchedRoute).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return MatchedRoute__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of MatchedRoute.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*MatchedRoute) bool {
|
|
JSC.markBinding(@src());
|
|
return MatchedRoute__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *MatchedRoute, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(MatchedRoute__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn MatchedRoute__fromJS(JSC.JSValue) ?*MatchedRoute;
|
|
extern fn MatchedRoute__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn MatchedRoute__create(globalObject: *JSC.JSGlobalObject, ptr: ?*MatchedRoute) JSC.JSValue;
|
|
|
|
extern fn MatchedRoute__dangerouslySetPtr(JSC.JSValue, ?*MatchedRoute) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(MatchedRoute.finalize) != (fn (*MatchedRoute) callconv(.C) void)) {
|
|
@compileLog("MatchedRoute.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(MatchedRoute.getFilePath) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getFilePath to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getKind) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getKind to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getName) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getName to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getParams) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getParams to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getPathname) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getPathname to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getQuery) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getQuery to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getScriptSrc) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getScriptSrc to be a getter");
|
|
|
|
if (@TypeOf(MatchedRoute.getScriptSrc) != GetterType)
|
|
@compileLog("Expected MatchedRoute.getScriptSrc to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(MatchedRoute.finalize, .{ .name = "MatchedRouteClass__finalize" });
|
|
@export(MatchedRoute.getFilePath, .{ .name = "MatchedRoutePrototype__getFilePath" });
|
|
@export(MatchedRoute.getKind, .{ .name = "MatchedRoutePrototype__getKind" });
|
|
@export(MatchedRoute.getName, .{ .name = "MatchedRoutePrototype__getName" });
|
|
@export(MatchedRoute.getParams, .{ .name = "MatchedRoutePrototype__getParams" });
|
|
@export(MatchedRoute.getPathname, .{ .name = "MatchedRoutePrototype__getPathname" });
|
|
@export(MatchedRoute.getQuery, .{ .name = "MatchedRoutePrototype__getQuery" });
|
|
@export(MatchedRoute.getScriptSrc, .{ .name = "MatchedRoutePrototype__getScriptSrc" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSNodeJSFS = struct {
|
|
const NodeJSFS = Classes.NodeJSFS;
|
|
const GetterType = fn (*NodeJSFS, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*NodeJSFS, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*NodeJSFS, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*NodeJSFS, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*NodeJSFS, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*NodeJSFS {
|
|
JSC.markBinding(@src());
|
|
return NodeJSFS__fromJS(value);
|
|
}
|
|
|
|
/// Get the NodeJSFS constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return NodeJSFS__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of NodeJSFS
|
|
pub fn toJS(this: *NodeJSFS, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = NodeJSFS__create(globalObject, this);
|
|
std.debug.assert(value__.as(NodeJSFS).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return NodeJSFS__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of NodeJSFS.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*NodeJSFS) bool {
|
|
JSC.markBinding(@src());
|
|
return NodeJSFS__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *NodeJSFS, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(NodeJSFS__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn NodeJSFS__fromJS(JSC.JSValue) ?*NodeJSFS;
|
|
extern fn NodeJSFS__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn NodeJSFS__create(globalObject: *JSC.JSGlobalObject, ptr: ?*NodeJSFS) JSC.JSValue;
|
|
|
|
extern fn NodeJSFS__dangerouslySetPtr(JSC.JSValue, ?*NodeJSFS) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(NodeJSFS.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*NodeJSFS)) {
|
|
@compileLog("NodeJSFS.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(NodeJSFS.access) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.access to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.access)));
|
|
if (@TypeOf(NodeJSFS.accessSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.accessSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.accessSync)));
|
|
if (@TypeOf(NodeJSFS.appendFile) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.appendFile to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.appendFile)));
|
|
if (@TypeOf(NodeJSFS.appendFileSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.appendFileSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.appendFileSync)));
|
|
if (@TypeOf(NodeJSFS.chmod) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.chmod to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.chmod)));
|
|
if (@TypeOf(NodeJSFS.chmodSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.chmodSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.chmodSync)));
|
|
if (@TypeOf(NodeJSFS.chown) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.chown to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.chown)));
|
|
if (@TypeOf(NodeJSFS.chownSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.chownSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.chownSync)));
|
|
if (@TypeOf(NodeJSFS.close) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.close to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.close)));
|
|
if (@TypeOf(NodeJSFS.closeSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.closeSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.closeSync)));
|
|
if (@TypeOf(NodeJSFS.copyFile) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.copyFile to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.copyFile)));
|
|
if (@TypeOf(NodeJSFS.copyFileSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.copyFileSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.copyFileSync)));
|
|
if (@TypeOf(NodeJSFS.getDirent) != GetterType)
|
|
@compileLog("Expected NodeJSFS.getDirent to be a getter");
|
|
|
|
if (@TypeOf(NodeJSFS.exists) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.exists to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.exists)));
|
|
if (@TypeOf(NodeJSFS.existsSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.existsSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.existsSync)));
|
|
if (@TypeOf(NodeJSFS.fchmod) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fchmod to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fchmod)));
|
|
if (@TypeOf(NodeJSFS.fchmodSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fchmodSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fchmodSync)));
|
|
if (@TypeOf(NodeJSFS.fchown) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fchown to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fchown)));
|
|
if (@TypeOf(NodeJSFS.fchownSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fchownSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fchownSync)));
|
|
if (@TypeOf(NodeJSFS.fdatasync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fdatasync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fdatasync)));
|
|
if (@TypeOf(NodeJSFS.fdatasyncSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fdatasyncSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fdatasyncSync)));
|
|
if (@TypeOf(NodeJSFS.fstat) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fstat to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fstat)));
|
|
if (@TypeOf(NodeJSFS.fstatSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fstatSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fstatSync)));
|
|
if (@TypeOf(NodeJSFS.fsync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fsync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fsync)));
|
|
if (@TypeOf(NodeJSFS.fsyncSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.fsyncSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.fsyncSync)));
|
|
if (@TypeOf(NodeJSFS.ftruncate) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.ftruncate to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.ftruncate)));
|
|
if (@TypeOf(NodeJSFS.ftruncateSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.ftruncateSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.ftruncateSync)));
|
|
if (@TypeOf(NodeJSFS.futimes) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.futimes to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.futimes)));
|
|
if (@TypeOf(NodeJSFS.futimesSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.futimesSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.futimesSync)));
|
|
if (@TypeOf(NodeJSFS.lchmod) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lchmod to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lchmod)));
|
|
if (@TypeOf(NodeJSFS.lchmodSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lchmodSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lchmodSync)));
|
|
if (@TypeOf(NodeJSFS.lchown) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lchown to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lchown)));
|
|
if (@TypeOf(NodeJSFS.lchownSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lchownSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lchownSync)));
|
|
if (@TypeOf(NodeJSFS.link) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.link to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.link)));
|
|
if (@TypeOf(NodeJSFS.linkSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.linkSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.linkSync)));
|
|
if (@TypeOf(NodeJSFS.lstat) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lstat to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lstat)));
|
|
if (@TypeOf(NodeJSFS.lstatSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lstatSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lstatSync)));
|
|
if (@TypeOf(NodeJSFS.lutimes) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lutimes to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lutimes)));
|
|
if (@TypeOf(NodeJSFS.lutimesSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.lutimesSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.lutimesSync)));
|
|
if (@TypeOf(NodeJSFS.mkdir) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.mkdir to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.mkdir)));
|
|
if (@TypeOf(NodeJSFS.mkdirSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.mkdirSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.mkdirSync)));
|
|
if (@TypeOf(NodeJSFS.mkdtemp) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.mkdtemp to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.mkdtemp)));
|
|
if (@TypeOf(NodeJSFS.mkdtempSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.mkdtempSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.mkdtempSync)));
|
|
if (@TypeOf(NodeJSFS.open) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.open to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.open)));
|
|
if (@TypeOf(NodeJSFS.opendir) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.opendir to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.opendir)));
|
|
if (@TypeOf(NodeJSFS.opendirSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.opendirSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.opendirSync)));
|
|
if (@TypeOf(NodeJSFS.openSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.openSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.openSync)));
|
|
if (@TypeOf(NodeJSFS.read) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.read to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.read)));
|
|
if (@TypeOf(NodeJSFS.readdir) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readdir to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readdir)));
|
|
if (@TypeOf(NodeJSFS.readdirSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readdirSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readdirSync)));
|
|
if (@TypeOf(NodeJSFS.readFile) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readFile to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readFile)));
|
|
if (@TypeOf(NodeJSFS.readFileSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readFileSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readFileSync)));
|
|
if (@TypeOf(NodeJSFS.readlink) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readlink to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readlink)));
|
|
if (@TypeOf(NodeJSFS.readlinkSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readlinkSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readlinkSync)));
|
|
if (@TypeOf(NodeJSFS.readSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readSync)));
|
|
if (@TypeOf(NodeJSFS.readv) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readv to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readv)));
|
|
if (@TypeOf(NodeJSFS.readvSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.readvSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.readvSync)));
|
|
if (@TypeOf(NodeJSFS.realpath) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.realpath to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.realpath)));
|
|
if (@TypeOf(NodeJSFS.realpathSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.realpathSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.realpathSync)));
|
|
if (@TypeOf(NodeJSFS.rename) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.rename to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.rename)));
|
|
if (@TypeOf(NodeJSFS.renameSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.renameSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.renameSync)));
|
|
if (@TypeOf(NodeJSFS.rm) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.rm to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.rm)));
|
|
if (@TypeOf(NodeJSFS.rmdir) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.rmdir to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.rmdir)));
|
|
if (@TypeOf(NodeJSFS.rmdirSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.rmdirSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.rmdirSync)));
|
|
if (@TypeOf(NodeJSFS.rmSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.rmSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.rmSync)));
|
|
if (@TypeOf(NodeJSFS.stat) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.stat to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.stat)));
|
|
if (@TypeOf(NodeJSFS.getStats) != GetterType)
|
|
@compileLog("Expected NodeJSFS.getStats to be a getter");
|
|
|
|
if (@TypeOf(NodeJSFS.statSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.statSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.statSync)));
|
|
if (@TypeOf(NodeJSFS.symlink) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.symlink to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.symlink)));
|
|
if (@TypeOf(NodeJSFS.symlinkSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.symlinkSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.symlinkSync)));
|
|
if (@TypeOf(NodeJSFS.truncate) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.truncate to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.truncate)));
|
|
if (@TypeOf(NodeJSFS.truncateSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.truncateSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.truncateSync)));
|
|
if (@TypeOf(NodeJSFS.unlink) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.unlink to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.unlink)));
|
|
if (@TypeOf(NodeJSFS.unlinkSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.unlinkSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.unlinkSync)));
|
|
if (@TypeOf(NodeJSFS.utimes) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.utimes to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.utimes)));
|
|
if (@TypeOf(NodeJSFS.utimesSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.utimesSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.utimesSync)));
|
|
if (@TypeOf(NodeJSFS.write) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.write to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.write)));
|
|
if (@TypeOf(NodeJSFS.writeFile) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.writeFile to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.writeFile)));
|
|
if (@TypeOf(NodeJSFS.writeFileSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.writeFileSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.writeFileSync)));
|
|
if (@TypeOf(NodeJSFS.writeSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.writeSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.writeSync)));
|
|
if (@TypeOf(NodeJSFS.writev) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.writev to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.writev)));
|
|
if (@TypeOf(NodeJSFS.writevSync) != CallbackType)
|
|
@compileLog("Expected NodeJSFS.writevSync to be a callback but received " ++ @typeName(@TypeOf(NodeJSFS.writevSync)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(NodeJSFS.access, .{ .name = "NodeJSFSPrototype__access" });
|
|
@export(NodeJSFS.accessSync, .{ .name = "NodeJSFSPrototype__accessSync" });
|
|
@export(NodeJSFS.appendFile, .{ .name = "NodeJSFSPrototype__appendFile" });
|
|
@export(NodeJSFS.appendFileSync, .{ .name = "NodeJSFSPrototype__appendFileSync" });
|
|
@export(NodeJSFS.chmod, .{ .name = "NodeJSFSPrototype__chmod" });
|
|
@export(NodeJSFS.chmodSync, .{ .name = "NodeJSFSPrototype__chmodSync" });
|
|
@export(NodeJSFS.chown, .{ .name = "NodeJSFSPrototype__chown" });
|
|
@export(NodeJSFS.chownSync, .{ .name = "NodeJSFSPrototype__chownSync" });
|
|
@export(NodeJSFS.close, .{ .name = "NodeJSFSPrototype__close" });
|
|
@export(NodeJSFS.closeSync, .{ .name = "NodeJSFSPrototype__closeSync" });
|
|
@export(NodeJSFS.constructor, .{ .name = "NodeJSFSClass__construct" });
|
|
@export(NodeJSFS.copyFile, .{ .name = "NodeJSFSPrototype__copyFile" });
|
|
@export(NodeJSFS.copyFileSync, .{ .name = "NodeJSFSPrototype__copyFileSync" });
|
|
@export(NodeJSFS.exists, .{ .name = "NodeJSFSPrototype__exists" });
|
|
@export(NodeJSFS.existsSync, .{ .name = "NodeJSFSPrototype__existsSync" });
|
|
@export(NodeJSFS.fchmod, .{ .name = "NodeJSFSPrototype__fchmod" });
|
|
@export(NodeJSFS.fchmodSync, .{ .name = "NodeJSFSPrototype__fchmodSync" });
|
|
@export(NodeJSFS.fchown, .{ .name = "NodeJSFSPrototype__fchown" });
|
|
@export(NodeJSFS.fchownSync, .{ .name = "NodeJSFSPrototype__fchownSync" });
|
|
@export(NodeJSFS.fdatasync, .{ .name = "NodeJSFSPrototype__fdatasync" });
|
|
@export(NodeJSFS.fdatasyncSync, .{ .name = "NodeJSFSPrototype__fdatasyncSync" });
|
|
@export(NodeJSFS.fstat, .{ .name = "NodeJSFSPrototype__fstat" });
|
|
@export(NodeJSFS.fstatSync, .{ .name = "NodeJSFSPrototype__fstatSync" });
|
|
@export(NodeJSFS.fsync, .{ .name = "NodeJSFSPrototype__fsync" });
|
|
@export(NodeJSFS.fsyncSync, .{ .name = "NodeJSFSPrototype__fsyncSync" });
|
|
@export(NodeJSFS.ftruncate, .{ .name = "NodeJSFSPrototype__ftruncate" });
|
|
@export(NodeJSFS.ftruncateSync, .{ .name = "NodeJSFSPrototype__ftruncateSync" });
|
|
@export(NodeJSFS.futimes, .{ .name = "NodeJSFSPrototype__futimes" });
|
|
@export(NodeJSFS.futimesSync, .{ .name = "NodeJSFSPrototype__futimesSync" });
|
|
@export(NodeJSFS.getDirent, .{ .name = "NodeJSFSPrototype__getDirent" });
|
|
@export(NodeJSFS.getStats, .{ .name = "NodeJSFSPrototype__getStats" });
|
|
@export(NodeJSFS.lchmod, .{ .name = "NodeJSFSPrototype__lchmod" });
|
|
@export(NodeJSFS.lchmodSync, .{ .name = "NodeJSFSPrototype__lchmodSync" });
|
|
@export(NodeJSFS.lchown, .{ .name = "NodeJSFSPrototype__lchown" });
|
|
@export(NodeJSFS.lchownSync, .{ .name = "NodeJSFSPrototype__lchownSync" });
|
|
@export(NodeJSFS.link, .{ .name = "NodeJSFSPrototype__link" });
|
|
@export(NodeJSFS.linkSync, .{ .name = "NodeJSFSPrototype__linkSync" });
|
|
@export(NodeJSFS.lstat, .{ .name = "NodeJSFSPrototype__lstat" });
|
|
@export(NodeJSFS.lstatSync, .{ .name = "NodeJSFSPrototype__lstatSync" });
|
|
@export(NodeJSFS.lutimes, .{ .name = "NodeJSFSPrototype__lutimes" });
|
|
@export(NodeJSFS.lutimesSync, .{ .name = "NodeJSFSPrototype__lutimesSync" });
|
|
@export(NodeJSFS.mkdir, .{ .name = "NodeJSFSPrototype__mkdir" });
|
|
@export(NodeJSFS.mkdirSync, .{ .name = "NodeJSFSPrototype__mkdirSync" });
|
|
@export(NodeJSFS.mkdtemp, .{ .name = "NodeJSFSPrototype__mkdtemp" });
|
|
@export(NodeJSFS.mkdtempSync, .{ .name = "NodeJSFSPrototype__mkdtempSync" });
|
|
@export(NodeJSFS.open, .{ .name = "NodeJSFSPrototype__open" });
|
|
@export(NodeJSFS.opendir, .{ .name = "NodeJSFSPrototype__opendir" });
|
|
@export(NodeJSFS.opendirSync, .{ .name = "NodeJSFSPrototype__opendirSync" });
|
|
@export(NodeJSFS.openSync, .{ .name = "NodeJSFSPrototype__openSync" });
|
|
@export(NodeJSFS.read, .{ .name = "NodeJSFSPrototype__read" });
|
|
@export(NodeJSFS.readdir, .{ .name = "NodeJSFSPrototype__readdir" });
|
|
@export(NodeJSFS.readdirSync, .{ .name = "NodeJSFSPrototype__readdirSync" });
|
|
@export(NodeJSFS.readFile, .{ .name = "NodeJSFSPrototype__readFile" });
|
|
@export(NodeJSFS.readFileSync, .{ .name = "NodeJSFSPrototype__readFileSync" });
|
|
@export(NodeJSFS.readlink, .{ .name = "NodeJSFSPrototype__readlink" });
|
|
@export(NodeJSFS.readlinkSync, .{ .name = "NodeJSFSPrototype__readlinkSync" });
|
|
@export(NodeJSFS.readSync, .{ .name = "NodeJSFSPrototype__readSync" });
|
|
@export(NodeJSFS.readv, .{ .name = "NodeJSFSPrototype__readv" });
|
|
@export(NodeJSFS.readvSync, .{ .name = "NodeJSFSPrototype__readvSync" });
|
|
@export(NodeJSFS.realpath, .{ .name = "NodeJSFSPrototype__realpath" });
|
|
@export(NodeJSFS.realpathSync, .{ .name = "NodeJSFSPrototype__realpathSync" });
|
|
@export(NodeJSFS.rename, .{ .name = "NodeJSFSPrototype__rename" });
|
|
@export(NodeJSFS.renameSync, .{ .name = "NodeJSFSPrototype__renameSync" });
|
|
@export(NodeJSFS.rm, .{ .name = "NodeJSFSPrototype__rm" });
|
|
@export(NodeJSFS.rmdir, .{ .name = "NodeJSFSPrototype__rmdir" });
|
|
@export(NodeJSFS.rmdirSync, .{ .name = "NodeJSFSPrototype__rmdirSync" });
|
|
@export(NodeJSFS.rmSync, .{ .name = "NodeJSFSPrototype__rmSync" });
|
|
@export(NodeJSFS.stat, .{ .name = "NodeJSFSPrototype__stat" });
|
|
@export(NodeJSFS.statSync, .{ .name = "NodeJSFSPrototype__statSync" });
|
|
@export(NodeJSFS.symlink, .{ .name = "NodeJSFSPrototype__symlink" });
|
|
@export(NodeJSFS.symlinkSync, .{ .name = "NodeJSFSPrototype__symlinkSync" });
|
|
@export(NodeJSFS.truncate, .{ .name = "NodeJSFSPrototype__truncate" });
|
|
@export(NodeJSFS.truncateSync, .{ .name = "NodeJSFSPrototype__truncateSync" });
|
|
@export(NodeJSFS.unlink, .{ .name = "NodeJSFSPrototype__unlink" });
|
|
@export(NodeJSFS.unlinkSync, .{ .name = "NodeJSFSPrototype__unlinkSync" });
|
|
@export(NodeJSFS.utimes, .{ .name = "NodeJSFSPrototype__utimes" });
|
|
@export(NodeJSFS.utimesSync, .{ .name = "NodeJSFSPrototype__utimesSync" });
|
|
@export(NodeJSFS.write, .{ .name = "NodeJSFSPrototype__write" });
|
|
@export(NodeJSFS.writeFile, .{ .name = "NodeJSFSPrototype__writeFile" });
|
|
@export(NodeJSFS.writeFileSync, .{ .name = "NodeJSFSPrototype__writeFileSync" });
|
|
@export(NodeJSFS.writeSync, .{ .name = "NodeJSFSPrototype__writeSync" });
|
|
@export(NodeJSFS.writev, .{ .name = "NodeJSFSPrototype__writev" });
|
|
@export(NodeJSFS.writevSync, .{ .name = "NodeJSFSPrototype__writevSync" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSRequest = struct {
|
|
const Request = Classes.Request;
|
|
const GetterType = fn (*Request, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Request, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Request, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Request, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Request, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Request {
|
|
JSC.markBinding(@src());
|
|
return Request__fromJS(value);
|
|
}
|
|
|
|
extern fn RequestPrototype__bodySetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn RequestPrototype__bodyGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Request.body` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn bodySetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
RequestPrototype__bodySetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Request.body` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn bodyGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = RequestPrototype__bodyGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn RequestPrototype__headersSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn RequestPrototype__headersGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Request.headers` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn headersSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
RequestPrototype__headersSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Request.headers` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn headersGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = RequestPrototype__headersGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn RequestPrototype__urlSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn RequestPrototype__urlGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Request.url` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn urlSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
RequestPrototype__urlSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Request.url` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn urlGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = RequestPrototype__urlGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the Request constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Request__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Request
|
|
pub fn toJS(this: *Request, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Request__create(globalObject, this);
|
|
std.debug.assert(value__.as(Request).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Request__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Request.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Request) bool {
|
|
JSC.markBinding(@src());
|
|
return Request__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Request, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Request__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Request__fromJS(JSC.JSValue) ?*Request;
|
|
extern fn Request__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Request__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Request) JSC.JSValue;
|
|
|
|
extern fn Request__dangerouslySetPtr(JSC.JSValue, ?*Request) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Request.estimatedSize) != (fn (*Request) callconv(.C) usize)) {
|
|
@compileLog("Request.estimatedSize is not a size function");
|
|
}
|
|
|
|
if (@TypeOf(Request.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Request)) {
|
|
@compileLog("Request.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Request.finalize) != (fn (*Request) callconv(.C) void)) {
|
|
@compileLog("Request.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Request.getArrayBuffer) != CallbackType)
|
|
@compileLog("Expected Request.getArrayBuffer to be a callback but received " ++ @typeName(@TypeOf(Request.getArrayBuffer)));
|
|
if (@TypeOf(Request.getBlob) != CallbackType)
|
|
@compileLog("Expected Request.getBlob to be a callback but received " ++ @typeName(@TypeOf(Request.getBlob)));
|
|
if (@TypeOf(Request.getBody) != GetterType)
|
|
@compileLog("Expected Request.getBody to be a getter");
|
|
|
|
if (@TypeOf(Request.getBodyUsed) != GetterType)
|
|
@compileLog("Expected Request.getBodyUsed to be a getter");
|
|
|
|
if (@TypeOf(Request.getCache) != GetterType)
|
|
@compileLog("Expected Request.getCache to be a getter");
|
|
|
|
if (@TypeOf(Request.doClone) != CallbackType)
|
|
@compileLog("Expected Request.doClone to be a callback but received " ++ @typeName(@TypeOf(Request.doClone)));
|
|
if (@TypeOf(Request.getCredentials) != GetterType)
|
|
@compileLog("Expected Request.getCredentials to be a getter");
|
|
|
|
if (@TypeOf(Request.getDestination) != GetterType)
|
|
@compileLog("Expected Request.getDestination to be a getter");
|
|
|
|
if (@TypeOf(Request.getFormData) != CallbackType)
|
|
@compileLog("Expected Request.getFormData to be a callback but received " ++ @typeName(@TypeOf(Request.getFormData)));
|
|
if (@TypeOf(Request.getHeaders) != GetterType)
|
|
@compileLog("Expected Request.getHeaders to be a getter");
|
|
|
|
if (@TypeOf(Request.getIntegrity) != GetterType)
|
|
@compileLog("Expected Request.getIntegrity to be a getter");
|
|
|
|
if (@TypeOf(Request.getJSON) != CallbackType)
|
|
@compileLog("Expected Request.getJSON to be a callback but received " ++ @typeName(@TypeOf(Request.getJSON)));
|
|
if (@TypeOf(Request.getMethod) != GetterType)
|
|
@compileLog("Expected Request.getMethod to be a getter");
|
|
|
|
if (@TypeOf(Request.getMode) != GetterType)
|
|
@compileLog("Expected Request.getMode to be a getter");
|
|
|
|
if (@TypeOf(Request.getRedirect) != GetterType)
|
|
@compileLog("Expected Request.getRedirect to be a getter");
|
|
|
|
if (@TypeOf(Request.getReferrer) != GetterType)
|
|
@compileLog("Expected Request.getReferrer to be a getter");
|
|
|
|
if (@TypeOf(Request.getReferrerPolicy) != GetterType)
|
|
@compileLog("Expected Request.getReferrerPolicy to be a getter");
|
|
|
|
if (@TypeOf(Request.getText) != CallbackType)
|
|
@compileLog("Expected Request.getText to be a callback but received " ++ @typeName(@TypeOf(Request.getText)));
|
|
if (@TypeOf(Request.getUrl) != GetterType)
|
|
@compileLog("Expected Request.getUrl to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(Request.constructor, .{ .name = "RequestClass__construct" });
|
|
@export(Request.doClone, .{ .name = "RequestPrototype__doClone" });
|
|
@export(Request.estimatedSize, .{ .name = "Request__estimatedSize" });
|
|
@export(Request.finalize, .{ .name = "RequestClass__finalize" });
|
|
@export(Request.getArrayBuffer, .{ .name = "RequestPrototype__getArrayBuffer" });
|
|
@export(Request.getBlob, .{ .name = "RequestPrototype__getBlob" });
|
|
@export(Request.getBody, .{ .name = "RequestPrototype__getBody" });
|
|
@export(Request.getBodyUsed, .{ .name = "RequestPrototype__getBodyUsed" });
|
|
@export(Request.getCache, .{ .name = "RequestPrototype__getCache" });
|
|
@export(Request.getCredentials, .{ .name = "RequestPrototype__getCredentials" });
|
|
@export(Request.getDestination, .{ .name = "RequestPrototype__getDestination" });
|
|
@export(Request.getFormData, .{ .name = "RequestPrototype__getFormData" });
|
|
@export(Request.getHeaders, .{ .name = "RequestPrototype__getHeaders" });
|
|
@export(Request.getIntegrity, .{ .name = "RequestPrototype__getIntegrity" });
|
|
@export(Request.getJSON, .{ .name = "RequestPrototype__getJSON" });
|
|
@export(Request.getMethod, .{ .name = "RequestPrototype__getMethod" });
|
|
@export(Request.getMode, .{ .name = "RequestPrototype__getMode" });
|
|
@export(Request.getRedirect, .{ .name = "RequestPrototype__getRedirect" });
|
|
@export(Request.getReferrer, .{ .name = "RequestPrototype__getReferrer" });
|
|
@export(Request.getReferrerPolicy, .{ .name = "RequestPrototype__getReferrerPolicy" });
|
|
@export(Request.getText, .{ .name = "RequestPrototype__getText" });
|
|
@export(Request.getUrl, .{ .name = "RequestPrototype__getUrl" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSResponse = struct {
|
|
const Response = Classes.Response;
|
|
const GetterType = fn (*Response, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Response, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Response, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Response, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Response, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Response {
|
|
JSC.markBinding(@src());
|
|
return Response__fromJS(value);
|
|
}
|
|
|
|
extern fn ResponsePrototype__bodySetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ResponsePrototype__bodyGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Response.body` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn bodySetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ResponsePrototype__bodySetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Response.body` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn bodyGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ResponsePrototype__bodyGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ResponsePrototype__headersSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ResponsePrototype__headersGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Response.headers` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn headersSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ResponsePrototype__headersSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Response.headers` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn headersGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ResponsePrototype__headersGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ResponsePrototype__statusTextSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ResponsePrototype__statusTextGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Response.statusText` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn statusTextSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ResponsePrototype__statusTextSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Response.statusText` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn statusTextGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ResponsePrototype__statusTextGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ResponsePrototype__urlSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ResponsePrototype__urlGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Response.url` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn urlSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ResponsePrototype__urlSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Response.url` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn urlGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ResponsePrototype__urlGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the Response constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Response__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Response
|
|
pub fn toJS(this: *Response, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Response__create(globalObject, this);
|
|
std.debug.assert(value__.as(Response).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Response__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Response.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Response) bool {
|
|
JSC.markBinding(@src());
|
|
return Response__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Response, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Response__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Response__fromJS(JSC.JSValue) ?*Response;
|
|
extern fn Response__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Response__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Response) JSC.JSValue;
|
|
|
|
extern fn Response__dangerouslySetPtr(JSC.JSValue, ?*Response) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Response.estimatedSize) != (fn (*Response) callconv(.C) usize)) {
|
|
@compileLog("Response.estimatedSize is not a size function");
|
|
}
|
|
|
|
if (@TypeOf(Response.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Response)) {
|
|
@compileLog("Response.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Response.finalize) != (fn (*Response) callconv(.C) void)) {
|
|
@compileLog("Response.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Response.getArrayBuffer) != CallbackType)
|
|
@compileLog("Expected Response.getArrayBuffer to be a callback but received " ++ @typeName(@TypeOf(Response.getArrayBuffer)));
|
|
if (@TypeOf(Response.getBlob) != CallbackType)
|
|
@compileLog("Expected Response.getBlob to be a callback but received " ++ @typeName(@TypeOf(Response.getBlob)));
|
|
if (@TypeOf(Response.getBody) != GetterType)
|
|
@compileLog("Expected Response.getBody to be a getter");
|
|
|
|
if (@TypeOf(Response.getBodyUsed) != GetterType)
|
|
@compileLog("Expected Response.getBodyUsed to be a getter");
|
|
|
|
if (@TypeOf(Response.doClone) != CallbackType)
|
|
@compileLog("Expected Response.doClone to be a callback but received " ++ @typeName(@TypeOf(Response.doClone)));
|
|
if (@TypeOf(Response.getFormData) != CallbackType)
|
|
@compileLog("Expected Response.getFormData to be a callback but received " ++ @typeName(@TypeOf(Response.getFormData)));
|
|
if (@TypeOf(Response.getHeaders) != GetterType)
|
|
@compileLog("Expected Response.getHeaders to be a getter");
|
|
|
|
if (@TypeOf(Response.getJSON) != CallbackType)
|
|
@compileLog("Expected Response.getJSON to be a callback but received " ++ @typeName(@TypeOf(Response.getJSON)));
|
|
if (@TypeOf(Response.getOK) != GetterType)
|
|
@compileLog("Expected Response.getOK to be a getter");
|
|
|
|
if (@TypeOf(Response.getRedirected) != GetterType)
|
|
@compileLog("Expected Response.getRedirected to be a getter");
|
|
|
|
if (@TypeOf(Response.getStatus) != GetterType)
|
|
@compileLog("Expected Response.getStatus to be a getter");
|
|
|
|
if (@TypeOf(Response.getStatusText) != GetterType)
|
|
@compileLog("Expected Response.getStatusText to be a getter");
|
|
|
|
if (@TypeOf(Response.getText) != CallbackType)
|
|
@compileLog("Expected Response.getText to be a callback but received " ++ @typeName(@TypeOf(Response.getText)));
|
|
if (@TypeOf(Response.getResponseType) != GetterType)
|
|
@compileLog("Expected Response.getResponseType to be a getter");
|
|
|
|
if (@TypeOf(Response.getURL) != GetterType)
|
|
@compileLog("Expected Response.getURL to be a getter");
|
|
|
|
if (@TypeOf(Response.constructError) != StaticCallbackType)
|
|
@compileLog("Expected Response.constructError to be a static callback");
|
|
if (@TypeOf(Response.constructJSON) != StaticCallbackType)
|
|
@compileLog("Expected Response.constructJSON to be a static callback");
|
|
if (@TypeOf(Response.constructRedirect) != StaticCallbackType)
|
|
@compileLog("Expected Response.constructRedirect to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(Response.constructError, .{ .name = "ResponseClass__constructError" });
|
|
@export(Response.constructJSON, .{ .name = "ResponseClass__constructJSON" });
|
|
@export(Response.constructor, .{ .name = "ResponseClass__construct" });
|
|
@export(Response.constructRedirect, .{ .name = "ResponseClass__constructRedirect" });
|
|
@export(Response.doClone, .{ .name = "ResponsePrototype__doClone" });
|
|
@export(Response.estimatedSize, .{ .name = "Response__estimatedSize" });
|
|
@export(Response.finalize, .{ .name = "ResponseClass__finalize" });
|
|
@export(Response.getArrayBuffer, .{ .name = "ResponsePrototype__getArrayBuffer" });
|
|
@export(Response.getBlob, .{ .name = "ResponsePrototype__getBlob" });
|
|
@export(Response.getBody, .{ .name = "ResponsePrototype__getBody" });
|
|
@export(Response.getBodyUsed, .{ .name = "ResponsePrototype__getBodyUsed" });
|
|
@export(Response.getFormData, .{ .name = "ResponsePrototype__getFormData" });
|
|
@export(Response.getHeaders, .{ .name = "ResponsePrototype__getHeaders" });
|
|
@export(Response.getJSON, .{ .name = "ResponsePrototype__getJSON" });
|
|
@export(Response.getOK, .{ .name = "ResponsePrototype__getOK" });
|
|
@export(Response.getRedirected, .{ .name = "ResponsePrototype__getRedirected" });
|
|
@export(Response.getResponseType, .{ .name = "ResponsePrototype__getResponseType" });
|
|
@export(Response.getStatus, .{ .name = "ResponsePrototype__getStatus" });
|
|
@export(Response.getStatusText, .{ .name = "ResponsePrototype__getStatusText" });
|
|
@export(Response.getText, .{ .name = "ResponsePrototype__getText" });
|
|
@export(Response.getURL, .{ .name = "ResponsePrototype__getURL" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA1 = struct {
|
|
const SHA1 = Classes.SHA1;
|
|
const GetterType = fn (*SHA1, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA1, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA1, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA1, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA1, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA1 {
|
|
JSC.markBinding(@src());
|
|
return SHA1__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA1 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA1__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA1
|
|
pub fn toJS(this: *SHA1, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA1__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA1).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA1__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA1.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA1) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA1__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA1, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA1__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA1__fromJS(JSC.JSValue) ?*SHA1;
|
|
extern fn SHA1__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA1__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA1) JSC.JSValue;
|
|
|
|
extern fn SHA1__dangerouslySetPtr(JSC.JSValue, ?*SHA1) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA1.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA1)) {
|
|
@compileLog("SHA1.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA1.finalize) != (fn (*SHA1) callconv(.C) void)) {
|
|
@compileLog("SHA1.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA1.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA1.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA1.digest) != CallbackType)
|
|
@compileLog("Expected SHA1.digest to be a callback but received " ++ @typeName(@TypeOf(SHA1.digest)));
|
|
if (@TypeOf(SHA1.update) != CallbackType)
|
|
@compileLog("Expected SHA1.update to be a callback but received " ++ @typeName(@TypeOf(SHA1.update)));
|
|
if (@TypeOf(SHA1.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA1.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA1.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA1.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA1.constructor, .{ .name = "SHA1Class__construct" });
|
|
@export(SHA1.digest, .{ .name = "SHA1Prototype__digest" });
|
|
@export(SHA1.finalize, .{ .name = "SHA1Class__finalize" });
|
|
@export(SHA1.getByteLength, .{ .name = "SHA1Prototype__getByteLength" });
|
|
@export(SHA1.getByteLengthStatic, .{ .name = "SHA1Class__getByteLengthStatic" });
|
|
@export(SHA1.hash, .{ .name = "SHA1Class__hash" });
|
|
@export(SHA1.update, .{ .name = "SHA1Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA224 = struct {
|
|
const SHA224 = Classes.SHA224;
|
|
const GetterType = fn (*SHA224, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA224, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA224, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA224, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA224, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA224 {
|
|
JSC.markBinding(@src());
|
|
return SHA224__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA224 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA224__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA224
|
|
pub fn toJS(this: *SHA224, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA224__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA224).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA224__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA224.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA224) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA224__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA224, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA224__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA224__fromJS(JSC.JSValue) ?*SHA224;
|
|
extern fn SHA224__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA224__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA224) JSC.JSValue;
|
|
|
|
extern fn SHA224__dangerouslySetPtr(JSC.JSValue, ?*SHA224) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA224.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA224)) {
|
|
@compileLog("SHA224.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA224.finalize) != (fn (*SHA224) callconv(.C) void)) {
|
|
@compileLog("SHA224.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA224.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA224.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA224.digest) != CallbackType)
|
|
@compileLog("Expected SHA224.digest to be a callback but received " ++ @typeName(@TypeOf(SHA224.digest)));
|
|
if (@TypeOf(SHA224.update) != CallbackType)
|
|
@compileLog("Expected SHA224.update to be a callback but received " ++ @typeName(@TypeOf(SHA224.update)));
|
|
if (@TypeOf(SHA224.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA224.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA224.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA224.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA224.constructor, .{ .name = "SHA224Class__construct" });
|
|
@export(SHA224.digest, .{ .name = "SHA224Prototype__digest" });
|
|
@export(SHA224.finalize, .{ .name = "SHA224Class__finalize" });
|
|
@export(SHA224.getByteLength, .{ .name = "SHA224Prototype__getByteLength" });
|
|
@export(SHA224.getByteLengthStatic, .{ .name = "SHA224Class__getByteLengthStatic" });
|
|
@export(SHA224.hash, .{ .name = "SHA224Class__hash" });
|
|
@export(SHA224.update, .{ .name = "SHA224Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA256 = struct {
|
|
const SHA256 = Classes.SHA256;
|
|
const GetterType = fn (*SHA256, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA256, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA256, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA256, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA256, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA256 {
|
|
JSC.markBinding(@src());
|
|
return SHA256__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA256 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA256__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA256
|
|
pub fn toJS(this: *SHA256, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA256__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA256).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA256__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA256.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA256) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA256__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA256, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA256__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA256__fromJS(JSC.JSValue) ?*SHA256;
|
|
extern fn SHA256__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA256__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA256) JSC.JSValue;
|
|
|
|
extern fn SHA256__dangerouslySetPtr(JSC.JSValue, ?*SHA256) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA256.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA256)) {
|
|
@compileLog("SHA256.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA256.finalize) != (fn (*SHA256) callconv(.C) void)) {
|
|
@compileLog("SHA256.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA256.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA256.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA256.digest) != CallbackType)
|
|
@compileLog("Expected SHA256.digest to be a callback but received " ++ @typeName(@TypeOf(SHA256.digest)));
|
|
if (@TypeOf(SHA256.update) != CallbackType)
|
|
@compileLog("Expected SHA256.update to be a callback but received " ++ @typeName(@TypeOf(SHA256.update)));
|
|
if (@TypeOf(SHA256.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA256.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA256.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA256.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA256.constructor, .{ .name = "SHA256Class__construct" });
|
|
@export(SHA256.digest, .{ .name = "SHA256Prototype__digest" });
|
|
@export(SHA256.finalize, .{ .name = "SHA256Class__finalize" });
|
|
@export(SHA256.getByteLength, .{ .name = "SHA256Prototype__getByteLength" });
|
|
@export(SHA256.getByteLengthStatic, .{ .name = "SHA256Class__getByteLengthStatic" });
|
|
@export(SHA256.hash, .{ .name = "SHA256Class__hash" });
|
|
@export(SHA256.update, .{ .name = "SHA256Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA384 = struct {
|
|
const SHA384 = Classes.SHA384;
|
|
const GetterType = fn (*SHA384, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA384, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA384, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA384, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA384, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA384 {
|
|
JSC.markBinding(@src());
|
|
return SHA384__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA384 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA384__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA384
|
|
pub fn toJS(this: *SHA384, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA384__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA384).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA384__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA384.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA384) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA384__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA384, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA384__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA384__fromJS(JSC.JSValue) ?*SHA384;
|
|
extern fn SHA384__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA384__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA384) JSC.JSValue;
|
|
|
|
extern fn SHA384__dangerouslySetPtr(JSC.JSValue, ?*SHA384) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA384.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA384)) {
|
|
@compileLog("SHA384.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA384.finalize) != (fn (*SHA384) callconv(.C) void)) {
|
|
@compileLog("SHA384.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA384.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA384.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA384.digest) != CallbackType)
|
|
@compileLog("Expected SHA384.digest to be a callback but received " ++ @typeName(@TypeOf(SHA384.digest)));
|
|
if (@TypeOf(SHA384.update) != CallbackType)
|
|
@compileLog("Expected SHA384.update to be a callback but received " ++ @typeName(@TypeOf(SHA384.update)));
|
|
if (@TypeOf(SHA384.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA384.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA384.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA384.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA384.constructor, .{ .name = "SHA384Class__construct" });
|
|
@export(SHA384.digest, .{ .name = "SHA384Prototype__digest" });
|
|
@export(SHA384.finalize, .{ .name = "SHA384Class__finalize" });
|
|
@export(SHA384.getByteLength, .{ .name = "SHA384Prototype__getByteLength" });
|
|
@export(SHA384.getByteLengthStatic, .{ .name = "SHA384Class__getByteLengthStatic" });
|
|
@export(SHA384.hash, .{ .name = "SHA384Class__hash" });
|
|
@export(SHA384.update, .{ .name = "SHA384Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA512 = struct {
|
|
const SHA512 = Classes.SHA512;
|
|
const GetterType = fn (*SHA512, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA512, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA512, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA512, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA512, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA512 {
|
|
JSC.markBinding(@src());
|
|
return SHA512__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA512 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA512__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA512
|
|
pub fn toJS(this: *SHA512, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA512__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA512).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA512__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA512.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA512) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA512__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA512, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA512__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA512__fromJS(JSC.JSValue) ?*SHA512;
|
|
extern fn SHA512__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA512__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA512) JSC.JSValue;
|
|
|
|
extern fn SHA512__dangerouslySetPtr(JSC.JSValue, ?*SHA512) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA512.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA512)) {
|
|
@compileLog("SHA512.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA512.finalize) != (fn (*SHA512) callconv(.C) void)) {
|
|
@compileLog("SHA512.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA512.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA512.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA512.digest) != CallbackType)
|
|
@compileLog("Expected SHA512.digest to be a callback but received " ++ @typeName(@TypeOf(SHA512.digest)));
|
|
if (@TypeOf(SHA512.update) != CallbackType)
|
|
@compileLog("Expected SHA512.update to be a callback but received " ++ @typeName(@TypeOf(SHA512.update)));
|
|
if (@TypeOf(SHA512.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA512.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA512.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA512.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA512.constructor, .{ .name = "SHA512Class__construct" });
|
|
@export(SHA512.digest, .{ .name = "SHA512Prototype__digest" });
|
|
@export(SHA512.finalize, .{ .name = "SHA512Class__finalize" });
|
|
@export(SHA512.getByteLength, .{ .name = "SHA512Prototype__getByteLength" });
|
|
@export(SHA512.getByteLengthStatic, .{ .name = "SHA512Class__getByteLengthStatic" });
|
|
@export(SHA512.hash, .{ .name = "SHA512Class__hash" });
|
|
@export(SHA512.update, .{ .name = "SHA512Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSHA512_256 = struct {
|
|
const SHA512_256 = Classes.SHA512_256;
|
|
const GetterType = fn (*SHA512_256, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*SHA512_256, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*SHA512_256, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*SHA512_256, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*SHA512_256, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*SHA512_256 {
|
|
JSC.markBinding(@src());
|
|
return SHA512_256__fromJS(value);
|
|
}
|
|
|
|
/// Get the SHA512_256 constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return SHA512_256__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of SHA512_256
|
|
pub fn toJS(this: *SHA512_256, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = SHA512_256__create(globalObject, this);
|
|
std.debug.assert(value__.as(SHA512_256).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return SHA512_256__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of SHA512_256.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*SHA512_256) bool {
|
|
JSC.markBinding(@src());
|
|
return SHA512_256__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *SHA512_256, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(SHA512_256__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn SHA512_256__fromJS(JSC.JSValue) ?*SHA512_256;
|
|
extern fn SHA512_256__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn SHA512_256__create(globalObject: *JSC.JSGlobalObject, ptr: ?*SHA512_256) JSC.JSValue;
|
|
|
|
extern fn SHA512_256__dangerouslySetPtr(JSC.JSValue, ?*SHA512_256) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(SHA512_256.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*SHA512_256)) {
|
|
@compileLog("SHA512_256.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(SHA512_256.finalize) != (fn (*SHA512_256) callconv(.C) void)) {
|
|
@compileLog("SHA512_256.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(SHA512_256.getByteLength) != GetterType)
|
|
@compileLog("Expected SHA512_256.getByteLength to be a getter");
|
|
|
|
if (@TypeOf(SHA512_256.digest) != CallbackType)
|
|
@compileLog("Expected SHA512_256.digest to be a callback but received " ++ @typeName(@TypeOf(SHA512_256.digest)));
|
|
if (@TypeOf(SHA512_256.update) != CallbackType)
|
|
@compileLog("Expected SHA512_256.update to be a callback but received " ++ @typeName(@TypeOf(SHA512_256.update)));
|
|
if (@TypeOf(SHA512_256.getByteLengthStatic) != StaticGetterType)
|
|
@compileLog("Expected SHA512_256.getByteLengthStatic to be a static getter");
|
|
|
|
if (@TypeOf(SHA512_256.hash) != StaticCallbackType)
|
|
@compileLog("Expected SHA512_256.hash to be a static callback");
|
|
if (!JSC.is_bindgen) {
|
|
@export(SHA512_256.constructor, .{ .name = "SHA512_256Class__construct" });
|
|
@export(SHA512_256.digest, .{ .name = "SHA512_256Prototype__digest" });
|
|
@export(SHA512_256.finalize, .{ .name = "SHA512_256Class__finalize" });
|
|
@export(SHA512_256.getByteLength, .{ .name = "SHA512_256Prototype__getByteLength" });
|
|
@export(SHA512_256.getByteLengthStatic, .{ .name = "SHA512_256Class__getByteLengthStatic" });
|
|
@export(SHA512_256.hash, .{ .name = "SHA512_256Class__hash" });
|
|
@export(SHA512_256.update, .{ .name = "SHA512_256Prototype__update" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSServerWebSocket = struct {
|
|
const ServerWebSocket = Classes.ServerWebSocket;
|
|
const GetterType = fn (*ServerWebSocket, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*ServerWebSocket, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*ServerWebSocket, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*ServerWebSocket, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*ServerWebSocket, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*ServerWebSocket {
|
|
JSC.markBinding(@src());
|
|
return ServerWebSocket__fromJS(value);
|
|
}
|
|
|
|
extern fn ServerWebSocketPrototype__dataSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ServerWebSocketPrototype__dataGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `ServerWebSocket.data` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ServerWebSocketPrototype__dataSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `ServerWebSocket.data` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ServerWebSocketPrototype__dataGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn ServerWebSocketPrototype__remoteAddressSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn ServerWebSocketPrototype__remoteAddressGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `ServerWebSocket.remoteAddress` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
ServerWebSocketPrototype__remoteAddressSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `ServerWebSocket.remoteAddress` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = ServerWebSocketPrototype__remoteAddressGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the ServerWebSocket constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return ServerWebSocket__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of ServerWebSocket
|
|
pub fn toJS(this: *ServerWebSocket, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = ServerWebSocket__create(globalObject, this);
|
|
std.debug.assert(value__.as(ServerWebSocket).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return ServerWebSocket__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of ServerWebSocket.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*ServerWebSocket) bool {
|
|
JSC.markBinding(@src());
|
|
return ServerWebSocket__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *ServerWebSocket, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(ServerWebSocket__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn ServerWebSocket__fromJS(JSC.JSValue) ?*ServerWebSocket;
|
|
extern fn ServerWebSocket__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn ServerWebSocket__create(globalObject: *JSC.JSGlobalObject, ptr: ?*ServerWebSocket) JSC.JSValue;
|
|
|
|
extern fn ServerWebSocket__dangerouslySetPtr(JSC.JSValue, ?*ServerWebSocket) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(ServerWebSocket.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*ServerWebSocket)) {
|
|
@compileLog("ServerWebSocket.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(ServerWebSocket.finalize) != (fn (*ServerWebSocket) callconv(.C) void)) {
|
|
@compileLog("ServerWebSocket.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(ServerWebSocket.getBinaryType) != GetterType)
|
|
@compileLog("Expected ServerWebSocket.getBinaryType to be a getter");
|
|
|
|
if (@TypeOf(ServerWebSocket.setBinaryType) != SetterType)
|
|
@compileLog("Expected ServerWebSocket.setBinaryType to be a setter");
|
|
if (@TypeOf(ServerWebSocket.close) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.close to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.close)));
|
|
if (@TypeOf(ServerWebSocket.cork) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.cork to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.cork)));
|
|
if (@TypeOf(ServerWebSocket.getData) != GetterType)
|
|
@compileLog("Expected ServerWebSocket.getData to be a getter");
|
|
|
|
if (@TypeOf(ServerWebSocket.setData) != SetterType)
|
|
@compileLog("Expected ServerWebSocket.setData to be a setter");
|
|
if (@TypeOf(ServerWebSocket.getBufferedAmount) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.getBufferedAmount to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.getBufferedAmount)));
|
|
if (@TypeOf(ServerWebSocket.isSubscribed) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.isSubscribed to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.isSubscribed)));
|
|
if (@TypeOf(ServerWebSocket.publish) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.publish to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.publish)));
|
|
if (@TypeOf(ServerWebSocket.publishBinaryWithoutTypeChecks) != fn (*ServerWebSocket, *JSC.JSGlobalObject, *JSC.JSString, *JSC.JSUint8Array) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected ServerWebSocket.publishBinaryWithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(ServerWebSocket.publishBinary) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.publishBinary to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.publishBinary)));
|
|
if (@TypeOf(ServerWebSocket.publishTextWithoutTypeChecks) != fn (*ServerWebSocket, *JSC.JSGlobalObject, *JSC.JSString, *JSC.JSString) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected ServerWebSocket.publishTextWithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(ServerWebSocket.publishText) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.publishText to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.publishText)));
|
|
if (@TypeOf(ServerWebSocket.getReadyState) != GetterType)
|
|
@compileLog("Expected ServerWebSocket.getReadyState to be a getter");
|
|
|
|
if (@TypeOf(ServerWebSocket.getRemoteAddress) != GetterType)
|
|
@compileLog("Expected ServerWebSocket.getRemoteAddress to be a getter");
|
|
|
|
if (@TypeOf(ServerWebSocket.send) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.send to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.send)));
|
|
if (@TypeOf(ServerWebSocket.sendBinaryWithoutTypeChecks) != fn (*ServerWebSocket, *JSC.JSGlobalObject, *JSC.JSUint8Array, bool) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected ServerWebSocket.sendBinaryWithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(ServerWebSocket.sendBinary) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.sendBinary to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.sendBinary)));
|
|
if (@TypeOf(ServerWebSocket.sendTextWithoutTypeChecks) != fn (*ServerWebSocket, *JSC.JSGlobalObject, *JSC.JSString, bool) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected ServerWebSocket.sendTextWithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(ServerWebSocket.sendText) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.sendText to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.sendText)));
|
|
if (@TypeOf(ServerWebSocket.subscribe) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.subscribe to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.subscribe)));
|
|
if (@TypeOf(ServerWebSocket.unsubscribe) != CallbackType)
|
|
@compileLog("Expected ServerWebSocket.unsubscribe to be a callback but received " ++ @typeName(@TypeOf(ServerWebSocket.unsubscribe)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(ServerWebSocket.close, .{ .name = "ServerWebSocketPrototype__close" });
|
|
@export(ServerWebSocket.constructor, .{ .name = "ServerWebSocketClass__construct" });
|
|
@export(ServerWebSocket.cork, .{ .name = "ServerWebSocketPrototype__cork" });
|
|
@export(ServerWebSocket.finalize, .{ .name = "ServerWebSocketClass__finalize" });
|
|
@export(ServerWebSocket.getBinaryType, .{ .name = "ServerWebSocketPrototype__getBinaryType" });
|
|
@export(ServerWebSocket.getBufferedAmount, .{ .name = "ServerWebSocketPrototype__getBufferedAmount" });
|
|
@export(ServerWebSocket.getData, .{ .name = "ServerWebSocketPrototype__getData" });
|
|
@export(ServerWebSocket.getReadyState, .{ .name = "ServerWebSocketPrototype__getReadyState" });
|
|
@export(ServerWebSocket.getRemoteAddress, .{ .name = "ServerWebSocketPrototype__getRemoteAddress" });
|
|
@export(ServerWebSocket.isSubscribed, .{ .name = "ServerWebSocketPrototype__isSubscribed" });
|
|
@export(ServerWebSocket.publish, .{ .name = "ServerWebSocketPrototype__publish" });
|
|
@export(ServerWebSocket.publishBinary, .{ .name = "ServerWebSocketPrototype__publishBinary" });
|
|
@export(ServerWebSocket.publishBinaryWithoutTypeChecks, .{ .name = "ServerWebSocketPrototype__publishBinaryWithoutTypeChecks" });
|
|
@export(ServerWebSocket.publishText, .{ .name = "ServerWebSocketPrototype__publishText" });
|
|
@export(ServerWebSocket.publishTextWithoutTypeChecks, .{ .name = "ServerWebSocketPrototype__publishTextWithoutTypeChecks" });
|
|
@export(ServerWebSocket.send, .{ .name = "ServerWebSocketPrototype__send" });
|
|
@export(ServerWebSocket.sendBinary, .{ .name = "ServerWebSocketPrototype__sendBinary" });
|
|
@export(ServerWebSocket.sendBinaryWithoutTypeChecks, .{ .name = "ServerWebSocketPrototype__sendBinaryWithoutTypeChecks" });
|
|
@export(ServerWebSocket.sendText, .{ .name = "ServerWebSocketPrototype__sendText" });
|
|
@export(ServerWebSocket.sendTextWithoutTypeChecks, .{ .name = "ServerWebSocketPrototype__sendTextWithoutTypeChecks" });
|
|
@export(ServerWebSocket.setBinaryType, .{ .name = "ServerWebSocketPrototype__setBinaryType" });
|
|
@export(ServerWebSocket.setData, .{ .name = "ServerWebSocketPrototype__setData" });
|
|
@export(ServerWebSocket.subscribe, .{ .name = "ServerWebSocketPrototype__subscribe" });
|
|
@export(ServerWebSocket.unsubscribe, .{ .name = "ServerWebSocketPrototype__unsubscribe" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSStats = struct {
|
|
const Stats = Classes.Stats;
|
|
const GetterType = fn (*Stats, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Stats, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Stats, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Stats, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Stats, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Stats {
|
|
JSC.markBinding(@src());
|
|
return Stats__fromJS(value);
|
|
}
|
|
|
|
extern fn StatsPrototype__atimeSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn StatsPrototype__atimeGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Stats.atime` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn atimeSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
StatsPrototype__atimeSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Stats.atime` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn atimeGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = StatsPrototype__atimeGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn StatsPrototype__ctimeSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn StatsPrototype__ctimeGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Stats.ctime` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn ctimeSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
StatsPrototype__ctimeSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Stats.ctime` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn ctimeGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = StatsPrototype__ctimeGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn StatsPrototype__mtimeSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn StatsPrototype__mtimeGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Stats.mtime` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn mtimeSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
StatsPrototype__mtimeSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Stats.mtime` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn mtimeGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = StatsPrototype__mtimeGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the Stats constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Stats__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Stats
|
|
pub fn toJS(this: *Stats, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Stats__create(globalObject, this);
|
|
std.debug.assert(value__.as(Stats).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Stats__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Stats.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Stats) bool {
|
|
JSC.markBinding(@src());
|
|
return Stats__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Stats, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Stats__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Stats__fromJS(JSC.JSValue) ?*Stats;
|
|
extern fn Stats__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Stats__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Stats) JSC.JSValue;
|
|
|
|
extern fn Stats__dangerouslySetPtr(JSC.JSValue, ?*Stats) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Stats.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Stats)) {
|
|
@compileLog("Stats.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Stats.finalize) != (fn (*Stats) callconv(.C) void)) {
|
|
@compileLog("Stats.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Stats.atime) != GetterType)
|
|
@compileLog("Expected Stats.atime to be a getter");
|
|
|
|
if (@TypeOf(Stats.atimeMs) != GetterType)
|
|
@compileLog("Expected Stats.atimeMs to be a getter");
|
|
|
|
if (@TypeOf(Stats.birthtime) != GetterType)
|
|
@compileLog("Expected Stats.birthtime to be a getter");
|
|
|
|
if (@TypeOf(Stats.birthtimeMs) != GetterType)
|
|
@compileLog("Expected Stats.birthtimeMs to be a getter");
|
|
|
|
if (@TypeOf(Stats.blksize) != GetterType)
|
|
@compileLog("Expected Stats.blksize to be a getter");
|
|
|
|
if (@TypeOf(Stats.blocks) != GetterType)
|
|
@compileLog("Expected Stats.blocks to be a getter");
|
|
|
|
if (@TypeOf(Stats.ctime) != GetterType)
|
|
@compileLog("Expected Stats.ctime to be a getter");
|
|
|
|
if (@TypeOf(Stats.ctimeMs) != GetterType)
|
|
@compileLog("Expected Stats.ctimeMs to be a getter");
|
|
|
|
if (@TypeOf(Stats.dev) != GetterType)
|
|
@compileLog("Expected Stats.dev to be a getter");
|
|
|
|
if (@TypeOf(Stats.gid) != GetterType)
|
|
@compileLog("Expected Stats.gid to be a getter");
|
|
|
|
if (@TypeOf(Stats.ino) != GetterType)
|
|
@compileLog("Expected Stats.ino to be a getter");
|
|
|
|
if (@TypeOf(Stats.isBlockDevice_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isBlockDevice_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isBlockDevice_) != CallbackType)
|
|
@compileLog("Expected Stats.isBlockDevice_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isBlockDevice_)));
|
|
if (@TypeOf(Stats.isCharacterDevice_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isCharacterDevice_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isCharacterDevice_) != CallbackType)
|
|
@compileLog("Expected Stats.isCharacterDevice_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isCharacterDevice_)));
|
|
if (@TypeOf(Stats.isDirectory_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isDirectory_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isDirectory_) != CallbackType)
|
|
@compileLog("Expected Stats.isDirectory_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isDirectory_)));
|
|
if (@TypeOf(Stats.isFIFO_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isFIFO_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isFIFO_) != CallbackType)
|
|
@compileLog("Expected Stats.isFIFO_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isFIFO_)));
|
|
if (@TypeOf(Stats.isFile_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isFile_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isFile_) != CallbackType)
|
|
@compileLog("Expected Stats.isFile_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isFile_)));
|
|
if (@TypeOf(Stats.isSocket_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isSocket_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isSocket_) != CallbackType)
|
|
@compileLog("Expected Stats.isSocket_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isSocket_)));
|
|
if (@TypeOf(Stats.isSymbolicLink_WithoutTypeChecks) != fn (
|
|
*Stats,
|
|
*JSC.JSGlobalObject,
|
|
) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected Stats.isSymbolicLink_WithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(Stats.isSymbolicLink_) != CallbackType)
|
|
@compileLog("Expected Stats.isSymbolicLink_ to be a callback but received " ++ @typeName(@TypeOf(Stats.isSymbolicLink_)));
|
|
if (@TypeOf(Stats.mode) != GetterType)
|
|
@compileLog("Expected Stats.mode to be a getter");
|
|
|
|
if (@TypeOf(Stats.mtime) != GetterType)
|
|
@compileLog("Expected Stats.mtime to be a getter");
|
|
|
|
if (@TypeOf(Stats.mtimeMs) != GetterType)
|
|
@compileLog("Expected Stats.mtimeMs to be a getter");
|
|
|
|
if (@TypeOf(Stats.nlink) != GetterType)
|
|
@compileLog("Expected Stats.nlink to be a getter");
|
|
|
|
if (@TypeOf(Stats.rdev) != GetterType)
|
|
@compileLog("Expected Stats.rdev to be a getter");
|
|
|
|
if (@TypeOf(Stats.size) != GetterType)
|
|
@compileLog("Expected Stats.size to be a getter");
|
|
|
|
if (@TypeOf(Stats.uid) != GetterType)
|
|
@compileLog("Expected Stats.uid to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(Stats.atime, .{ .name = "StatsPrototype__atime" });
|
|
@export(Stats.atimeMs, .{ .name = "StatsPrototype__atimeMs" });
|
|
@export(Stats.birthtime, .{ .name = "StatsPrototype__birthtime" });
|
|
@export(Stats.birthtimeMs, .{ .name = "StatsPrototype__birthtimeMs" });
|
|
@export(Stats.blksize, .{ .name = "StatsPrototype__blksize" });
|
|
@export(Stats.blocks, .{ .name = "StatsPrototype__blocks" });
|
|
@export(Stats.constructor, .{ .name = "StatsClass__construct" });
|
|
@export(Stats.ctime, .{ .name = "StatsPrototype__ctime" });
|
|
@export(Stats.ctimeMs, .{ .name = "StatsPrototype__ctimeMs" });
|
|
@export(Stats.dev, .{ .name = "StatsPrototype__dev" });
|
|
@export(Stats.finalize, .{ .name = "StatsClass__finalize" });
|
|
@export(Stats.gid, .{ .name = "StatsPrototype__gid" });
|
|
@export(Stats.ino, .{ .name = "StatsPrototype__ino" });
|
|
@export(Stats.isBlockDevice_, .{ .name = "StatsPrototype__isBlockDevice_" });
|
|
@export(Stats.isBlockDevice_WithoutTypeChecks, .{ .name = "StatsPrototype__isBlockDevice_WithoutTypeChecks" });
|
|
@export(Stats.isCharacterDevice_, .{ .name = "StatsPrototype__isCharacterDevice_" });
|
|
@export(Stats.isCharacterDevice_WithoutTypeChecks, .{ .name = "StatsPrototype__isCharacterDevice_WithoutTypeChecks" });
|
|
@export(Stats.isDirectory_, .{ .name = "StatsPrototype__isDirectory_" });
|
|
@export(Stats.isDirectory_WithoutTypeChecks, .{ .name = "StatsPrototype__isDirectory_WithoutTypeChecks" });
|
|
@export(Stats.isFIFO_, .{ .name = "StatsPrototype__isFIFO_" });
|
|
@export(Stats.isFIFO_WithoutTypeChecks, .{ .name = "StatsPrototype__isFIFO_WithoutTypeChecks" });
|
|
@export(Stats.isFile_, .{ .name = "StatsPrototype__isFile_" });
|
|
@export(Stats.isFile_WithoutTypeChecks, .{ .name = "StatsPrototype__isFile_WithoutTypeChecks" });
|
|
@export(Stats.isSocket_, .{ .name = "StatsPrototype__isSocket_" });
|
|
@export(Stats.isSocket_WithoutTypeChecks, .{ .name = "StatsPrototype__isSocket_WithoutTypeChecks" });
|
|
@export(Stats.isSymbolicLink_, .{ .name = "StatsPrototype__isSymbolicLink_" });
|
|
@export(Stats.isSymbolicLink_WithoutTypeChecks, .{ .name = "StatsPrototype__isSymbolicLink_WithoutTypeChecks" });
|
|
@export(Stats.mode, .{ .name = "StatsPrototype__mode" });
|
|
@export(Stats.mtime, .{ .name = "StatsPrototype__mtime" });
|
|
@export(Stats.mtimeMs, .{ .name = "StatsPrototype__mtimeMs" });
|
|
@export(Stats.nlink, .{ .name = "StatsPrototype__nlink" });
|
|
@export(Stats.rdev, .{ .name = "StatsPrototype__rdev" });
|
|
@export(Stats.size, .{ .name = "StatsPrototype__size" });
|
|
@export(Stats.uid, .{ .name = "StatsPrototype__uid" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSSubprocess = struct {
|
|
const Subprocess = Classes.Subprocess;
|
|
const GetterType = fn (*Subprocess, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Subprocess, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Subprocess, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Subprocess, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Subprocess, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Subprocess {
|
|
JSC.markBinding(@src());
|
|
return Subprocess__fromJS(value);
|
|
}
|
|
|
|
extern fn SubprocessPrototype__stderrSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn SubprocessPrototype__stderrGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Subprocess.stderr` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stderrSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
SubprocessPrototype__stderrSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Subprocess.stderr` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stderrGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = SubprocessPrototype__stderrGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn SubprocessPrototype__stdinSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn SubprocessPrototype__stdinGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Subprocess.stdin` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stdinSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
SubprocessPrototype__stdinSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Subprocess.stdin` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stdinGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = SubprocessPrototype__stdinGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn SubprocessPrototype__stdoutSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn SubprocessPrototype__stdoutGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `Subprocess.stdout` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stdoutSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
SubprocessPrototype__stdoutSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `Subprocess.stdout` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn stdoutGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = SubprocessPrototype__stdoutGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Create a new instance of Subprocess
|
|
pub fn toJS(this: *Subprocess, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Subprocess__create(globalObject, this);
|
|
std.debug.assert(value__.as(Subprocess).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Subprocess__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Subprocess.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Subprocess) bool {
|
|
JSC.markBinding(@src());
|
|
return Subprocess__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Subprocess, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Subprocess__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Subprocess__fromJS(JSC.JSValue) ?*Subprocess;
|
|
extern fn Subprocess__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Subprocess__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Subprocess) JSC.JSValue;
|
|
|
|
extern fn Subprocess__dangerouslySetPtr(JSC.JSValue, ?*Subprocess) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Subprocess.finalize) != (fn (*Subprocess) callconv(.C) void)) {
|
|
@compileLog("Subprocess.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Subprocess.getExitCode) != GetterType)
|
|
@compileLog("Expected Subprocess.getExitCode to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getExited) != GetterType)
|
|
@compileLog("Expected Subprocess.getExited to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.kill) != CallbackType)
|
|
@compileLog("Expected Subprocess.kill to be a callback but received " ++ @typeName(@TypeOf(Subprocess.kill)));
|
|
if (@TypeOf(Subprocess.getKilled) != GetterType)
|
|
@compileLog("Expected Subprocess.getKilled to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getPid) != GetterType)
|
|
@compileLog("Expected Subprocess.getPid to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getStdout) != GetterType)
|
|
@compileLog("Expected Subprocess.getStdout to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.doRef) != CallbackType)
|
|
@compileLog("Expected Subprocess.doRef to be a callback but received " ++ @typeName(@TypeOf(Subprocess.doRef)));
|
|
if (@TypeOf(Subprocess.getSignalCode) != GetterType)
|
|
@compileLog("Expected Subprocess.getSignalCode to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getStderr) != GetterType)
|
|
@compileLog("Expected Subprocess.getStderr to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getStdin) != GetterType)
|
|
@compileLog("Expected Subprocess.getStdin to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.getStdout) != GetterType)
|
|
@compileLog("Expected Subprocess.getStdout to be a getter");
|
|
|
|
if (@TypeOf(Subprocess.doUnref) != CallbackType)
|
|
@compileLog("Expected Subprocess.doUnref to be a callback but received " ++ @typeName(@TypeOf(Subprocess.doUnref)));
|
|
if (@TypeOf(Subprocess.getStdin) != GetterType)
|
|
@compileLog("Expected Subprocess.getStdin to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(Subprocess.doRef, .{ .name = "SubprocessPrototype__doRef" });
|
|
@export(Subprocess.doUnref, .{ .name = "SubprocessPrototype__doUnref" });
|
|
@export(Subprocess.finalize, .{ .name = "SubprocessClass__finalize" });
|
|
@export(Subprocess.getExitCode, .{ .name = "SubprocessPrototype__getExitCode" });
|
|
@export(Subprocess.getExited, .{ .name = "SubprocessPrototype__getExited" });
|
|
@export(Subprocess.getKilled, .{ .name = "SubprocessPrototype__getKilled" });
|
|
@export(Subprocess.getPid, .{ .name = "SubprocessPrototype__getPid" });
|
|
@export(Subprocess.getSignalCode, .{ .name = "SubprocessPrototype__getSignalCode" });
|
|
@export(Subprocess.getStderr, .{ .name = "SubprocessPrototype__getStderr" });
|
|
@export(Subprocess.getStdin, .{ .name = "SubprocessPrototype__getStdin" });
|
|
@export(Subprocess.getStdout, .{ .name = "SubprocessPrototype__getStdout" });
|
|
@export(Subprocess.hasPendingActivity, .{ .name = "Subprocess__hasPendingActivity" });
|
|
@export(Subprocess.kill, .{ .name = "SubprocessPrototype__kill" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSTCPSocket = struct {
|
|
const TCPSocket = Classes.TCPSocket;
|
|
const GetterType = fn (*TCPSocket, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*TCPSocket, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*TCPSocket, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*TCPSocket, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*TCPSocket, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*TCPSocket {
|
|
JSC.markBinding(@src());
|
|
return TCPSocket__fromJS(value);
|
|
}
|
|
|
|
extern fn TCPSocketPrototype__dataSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn TCPSocketPrototype__dataGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `TCPSocket.data` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
TCPSocketPrototype__dataSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `TCPSocket.data` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = TCPSocketPrototype__dataGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn TCPSocketPrototype__remoteAddressSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn TCPSocketPrototype__remoteAddressGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `TCPSocket.remoteAddress` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
TCPSocketPrototype__remoteAddressSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `TCPSocket.remoteAddress` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = TCPSocketPrototype__remoteAddressGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Create a new instance of TCPSocket
|
|
pub fn toJS(this: *TCPSocket, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = TCPSocket__create(globalObject, this);
|
|
std.debug.assert(value__.as(TCPSocket).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return TCPSocket__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of TCPSocket.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*TCPSocket) bool {
|
|
JSC.markBinding(@src());
|
|
return TCPSocket__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *TCPSocket, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(TCPSocket__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn TCPSocket__fromJS(JSC.JSValue) ?*TCPSocket;
|
|
extern fn TCPSocket__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn TCPSocket__create(globalObject: *JSC.JSGlobalObject, ptr: ?*TCPSocket) JSC.JSValue;
|
|
|
|
extern fn TCPSocket__dangerouslySetPtr(JSC.JSValue, ?*TCPSocket) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(TCPSocket.finalize) != (fn (*TCPSocket) callconv(.C) void)) {
|
|
@compileLog("TCPSocket.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(TCPSocket.getData) != GetterType)
|
|
@compileLog("Expected TCPSocket.getData to be a getter");
|
|
|
|
if (@TypeOf(TCPSocket.setData) != SetterType)
|
|
@compileLog("Expected TCPSocket.setData to be a setter");
|
|
if (@TypeOf(TCPSocket.end) != CallbackType)
|
|
@compileLog("Expected TCPSocket.end to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.end)));
|
|
if (@TypeOf(TCPSocket.flush) != CallbackType)
|
|
@compileLog("Expected TCPSocket.flush to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.flush)));
|
|
if (@TypeOf(TCPSocket.getListener) != GetterType)
|
|
@compileLog("Expected TCPSocket.getListener to be a getter");
|
|
|
|
if (@TypeOf(TCPSocket.getLocalPort) != GetterType)
|
|
@compileLog("Expected TCPSocket.getLocalPort to be a getter");
|
|
|
|
if (@TypeOf(TCPSocket.getReadyState) != GetterType)
|
|
@compileLog("Expected TCPSocket.getReadyState to be a getter");
|
|
|
|
if (@TypeOf(TCPSocket.ref) != CallbackType)
|
|
@compileLog("Expected TCPSocket.ref to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.ref)));
|
|
if (@TypeOf(TCPSocket.reload) != CallbackType)
|
|
@compileLog("Expected TCPSocket.reload to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.reload)));
|
|
if (@TypeOf(TCPSocket.getRemoteAddress) != GetterType)
|
|
@compileLog("Expected TCPSocket.getRemoteAddress to be a getter");
|
|
|
|
if (@TypeOf(TCPSocket.shutdown) != CallbackType)
|
|
@compileLog("Expected TCPSocket.shutdown to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.shutdown)));
|
|
if (@TypeOf(TCPSocket.timeout) != CallbackType)
|
|
@compileLog("Expected TCPSocket.timeout to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.timeout)));
|
|
if (@TypeOf(TCPSocket.unref) != CallbackType)
|
|
@compileLog("Expected TCPSocket.unref to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.unref)));
|
|
if (@TypeOf(TCPSocket.write) != CallbackType)
|
|
@compileLog("Expected TCPSocket.write to be a callback but received " ++ @typeName(@TypeOf(TCPSocket.write)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(TCPSocket.end, .{ .name = "TCPSocketPrototype__end" });
|
|
@export(TCPSocket.finalize, .{ .name = "TCPSocketClass__finalize" });
|
|
@export(TCPSocket.flush, .{ .name = "TCPSocketPrototype__flush" });
|
|
@export(TCPSocket.getData, .{ .name = "TCPSocketPrototype__getData" });
|
|
@export(TCPSocket.getListener, .{ .name = "TCPSocketPrototype__getListener" });
|
|
@export(TCPSocket.getLocalPort, .{ .name = "TCPSocketPrototype__getLocalPort" });
|
|
@export(TCPSocket.getReadyState, .{ .name = "TCPSocketPrototype__getReadyState" });
|
|
@export(TCPSocket.getRemoteAddress, .{ .name = "TCPSocketPrototype__getRemoteAddress" });
|
|
@export(TCPSocket.hasPendingActivity, .{ .name = "TCPSocket__hasPendingActivity" });
|
|
@export(TCPSocket.ref, .{ .name = "TCPSocketPrototype__ref" });
|
|
@export(TCPSocket.reload, .{ .name = "TCPSocketPrototype__reload" });
|
|
@export(TCPSocket.setData, .{ .name = "TCPSocketPrototype__setData" });
|
|
@export(TCPSocket.shutdown, .{ .name = "TCPSocketPrototype__shutdown" });
|
|
@export(TCPSocket.timeout, .{ .name = "TCPSocketPrototype__timeout" });
|
|
@export(TCPSocket.unref, .{ .name = "TCPSocketPrototype__unref" });
|
|
@export(TCPSocket.write, .{ .name = "TCPSocketPrototype__write" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSTLSSocket = struct {
|
|
const TLSSocket = Classes.TLSSocket;
|
|
const GetterType = fn (*TLSSocket, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*TLSSocket, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*TLSSocket, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*TLSSocket, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*TLSSocket, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*TLSSocket {
|
|
JSC.markBinding(@src());
|
|
return TLSSocket__fromJS(value);
|
|
}
|
|
|
|
extern fn TLSSocketPrototype__dataSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn TLSSocketPrototype__dataGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `TLSSocket.data` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
TLSSocketPrototype__dataSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `TLSSocket.data` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn dataGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = TLSSocketPrototype__dataGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
extern fn TLSSocketPrototype__remoteAddressSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn TLSSocketPrototype__remoteAddressGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `TLSSocket.remoteAddress` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
TLSSocketPrototype__remoteAddressSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `TLSSocket.remoteAddress` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn remoteAddressGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = TLSSocketPrototype__remoteAddressGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Create a new instance of TLSSocket
|
|
pub fn toJS(this: *TLSSocket, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = TLSSocket__create(globalObject, this);
|
|
std.debug.assert(value__.as(TLSSocket).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return TLSSocket__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of TLSSocket.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*TLSSocket) bool {
|
|
JSC.markBinding(@src());
|
|
return TLSSocket__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *TLSSocket, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(TLSSocket__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn TLSSocket__fromJS(JSC.JSValue) ?*TLSSocket;
|
|
extern fn TLSSocket__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn TLSSocket__create(globalObject: *JSC.JSGlobalObject, ptr: ?*TLSSocket) JSC.JSValue;
|
|
|
|
extern fn TLSSocket__dangerouslySetPtr(JSC.JSValue, ?*TLSSocket) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(TLSSocket.finalize) != (fn (*TLSSocket) callconv(.C) void)) {
|
|
@compileLog("TLSSocket.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(TLSSocket.getData) != GetterType)
|
|
@compileLog("Expected TLSSocket.getData to be a getter");
|
|
|
|
if (@TypeOf(TLSSocket.setData) != SetterType)
|
|
@compileLog("Expected TLSSocket.setData to be a setter");
|
|
if (@TypeOf(TLSSocket.end) != CallbackType)
|
|
@compileLog("Expected TLSSocket.end to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.end)));
|
|
if (@TypeOf(TLSSocket.flush) != CallbackType)
|
|
@compileLog("Expected TLSSocket.flush to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.flush)));
|
|
if (@TypeOf(TLSSocket.getListener) != GetterType)
|
|
@compileLog("Expected TLSSocket.getListener to be a getter");
|
|
|
|
if (@TypeOf(TLSSocket.getLocalPort) != GetterType)
|
|
@compileLog("Expected TLSSocket.getLocalPort to be a getter");
|
|
|
|
if (@TypeOf(TLSSocket.getReadyState) != GetterType)
|
|
@compileLog("Expected TLSSocket.getReadyState to be a getter");
|
|
|
|
if (@TypeOf(TLSSocket.ref) != CallbackType)
|
|
@compileLog("Expected TLSSocket.ref to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.ref)));
|
|
if (@TypeOf(TLSSocket.reload) != CallbackType)
|
|
@compileLog("Expected TLSSocket.reload to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.reload)));
|
|
if (@TypeOf(TLSSocket.getRemoteAddress) != GetterType)
|
|
@compileLog("Expected TLSSocket.getRemoteAddress to be a getter");
|
|
|
|
if (@TypeOf(TLSSocket.shutdown) != CallbackType)
|
|
@compileLog("Expected TLSSocket.shutdown to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.shutdown)));
|
|
if (@TypeOf(TLSSocket.timeout) != CallbackType)
|
|
@compileLog("Expected TLSSocket.timeout to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.timeout)));
|
|
if (@TypeOf(TLSSocket.unref) != CallbackType)
|
|
@compileLog("Expected TLSSocket.unref to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.unref)));
|
|
if (@TypeOf(TLSSocket.write) != CallbackType)
|
|
@compileLog("Expected TLSSocket.write to be a callback but received " ++ @typeName(@TypeOf(TLSSocket.write)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(TLSSocket.end, .{ .name = "TLSSocketPrototype__end" });
|
|
@export(TLSSocket.finalize, .{ .name = "TLSSocketClass__finalize" });
|
|
@export(TLSSocket.flush, .{ .name = "TLSSocketPrototype__flush" });
|
|
@export(TLSSocket.getData, .{ .name = "TLSSocketPrototype__getData" });
|
|
@export(TLSSocket.getListener, .{ .name = "TLSSocketPrototype__getListener" });
|
|
@export(TLSSocket.getLocalPort, .{ .name = "TLSSocketPrototype__getLocalPort" });
|
|
@export(TLSSocket.getReadyState, .{ .name = "TLSSocketPrototype__getReadyState" });
|
|
@export(TLSSocket.getRemoteAddress, .{ .name = "TLSSocketPrototype__getRemoteAddress" });
|
|
@export(TLSSocket.hasPendingActivity, .{ .name = "TLSSocket__hasPendingActivity" });
|
|
@export(TLSSocket.ref, .{ .name = "TLSSocketPrototype__ref" });
|
|
@export(TLSSocket.reload, .{ .name = "TLSSocketPrototype__reload" });
|
|
@export(TLSSocket.setData, .{ .name = "TLSSocketPrototype__setData" });
|
|
@export(TLSSocket.shutdown, .{ .name = "TLSSocketPrototype__shutdown" });
|
|
@export(TLSSocket.timeout, .{ .name = "TLSSocketPrototype__timeout" });
|
|
@export(TLSSocket.unref, .{ .name = "TLSSocketPrototype__unref" });
|
|
@export(TLSSocket.write, .{ .name = "TLSSocketPrototype__write" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSTextDecoder = struct {
|
|
const TextDecoder = Classes.TextDecoder;
|
|
const GetterType = fn (*TextDecoder, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*TextDecoder, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*TextDecoder, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*TextDecoder, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*TextDecoder, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*TextDecoder {
|
|
JSC.markBinding(@src());
|
|
return TextDecoder__fromJS(value);
|
|
}
|
|
|
|
extern fn TextDecoderPrototype__encodingSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
|
|
|
|
extern fn TextDecoderPrototype__encodingGetCachedValue(JSC.JSValue) JSC.JSValue;
|
|
|
|
/// `TextDecoder.encoding` setter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn encodingSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
TextDecoderPrototype__encodingSetCachedValue(thisValue, globalObject, value);
|
|
}
|
|
|
|
/// `TextDecoder.encoding` getter
|
|
/// This value will be visited by the garbage collector.
|
|
pub fn encodingGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
const result = TextDecoderPrototype__encodingGetCachedValue(thisValue);
|
|
if (result == .zero)
|
|
return null;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Get the TextDecoder constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return TextDecoder__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of TextDecoder
|
|
pub fn toJS(this: *TextDecoder, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = TextDecoder__create(globalObject, this);
|
|
std.debug.assert(value__.as(TextDecoder).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return TextDecoder__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of TextDecoder.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*TextDecoder) bool {
|
|
JSC.markBinding(@src());
|
|
return TextDecoder__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *TextDecoder, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(TextDecoder__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn TextDecoder__fromJS(JSC.JSValue) ?*TextDecoder;
|
|
extern fn TextDecoder__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn TextDecoder__create(globalObject: *JSC.JSGlobalObject, ptr: ?*TextDecoder) JSC.JSValue;
|
|
|
|
extern fn TextDecoder__dangerouslySetPtr(JSC.JSValue, ?*TextDecoder) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(TextDecoder.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*TextDecoder)) {
|
|
@compileLog("TextDecoder.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(TextDecoder.finalize) != (fn (*TextDecoder) callconv(.C) void)) {
|
|
@compileLog("TextDecoder.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(TextDecoder.decodeWithoutTypeChecks) != fn (*TextDecoder, *JSC.JSGlobalObject, *JSC.JSUint8Array) callconv(.C) JSC.JSValue)
|
|
@compileLog("Expected TextDecoder.decodeWithoutTypeChecks to be a DOMJIT function");
|
|
if (@TypeOf(TextDecoder.decode) != CallbackType)
|
|
@compileLog("Expected TextDecoder.decode to be a callback but received " ++ @typeName(@TypeOf(TextDecoder.decode)));
|
|
if (@TypeOf(TextDecoder.getEncoding) != GetterType)
|
|
@compileLog("Expected TextDecoder.getEncoding to be a getter");
|
|
|
|
if (@TypeOf(TextDecoder.getFatal) != GetterType)
|
|
@compileLog("Expected TextDecoder.getFatal to be a getter");
|
|
|
|
if (!JSC.is_bindgen) {
|
|
@export(TextDecoder.constructor, .{ .name = "TextDecoderClass__construct" });
|
|
@export(TextDecoder.decode, .{ .name = "TextDecoderPrototype__decode" });
|
|
@export(TextDecoder.decodeWithoutTypeChecks, .{ .name = "TextDecoderPrototype__decodeWithoutTypeChecks" });
|
|
@export(TextDecoder.finalize, .{ .name = "TextDecoderClass__finalize" });
|
|
@export(TextDecoder.getEncoding, .{ .name = "TextDecoderPrototype__getEncoding" });
|
|
@export(TextDecoder.getFatal, .{ .name = "TextDecoderPrototype__getFatal" });
|
|
}
|
|
}
|
|
};
|
|
pub const JSTranspiler = struct {
|
|
const Transpiler = Classes.Transpiler;
|
|
const GetterType = fn (*Transpiler, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const GetterTypeWithThisValue = fn (*Transpiler, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
|
|
const SetterType = fn (*Transpiler, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const SetterTypeWithThisValue = fn (*Transpiler, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
|
|
const CallbackType = fn (*Transpiler, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
|
|
|
|
/// Return the pointer to the wrapped object.
|
|
/// If the object does not match the type, return null.
|
|
pub fn fromJS(value: JSC.JSValue) ?*Transpiler {
|
|
JSC.markBinding(@src());
|
|
return Transpiler__fromJS(value);
|
|
}
|
|
|
|
/// Get the Transpiler constructor value.
|
|
/// This loads lazily from the global object.
|
|
pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
return Transpiler__getConstructor(globalObject);
|
|
}
|
|
|
|
/// Create a new instance of Transpiler
|
|
pub fn toJS(this: *Transpiler, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
JSC.markBinding(@src());
|
|
if (comptime Environment.allow_assert) {
|
|
const value__ = Transpiler__create(globalObject, this);
|
|
std.debug.assert(value__.as(Transpiler).? == this); // If this fails, likely a C ABI issue.
|
|
return value__;
|
|
} else {
|
|
return Transpiler__create(globalObject, this);
|
|
}
|
|
}
|
|
|
|
/// Modify the internal ptr to point to a new instance of Transpiler.
|
|
pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Transpiler) bool {
|
|
JSC.markBinding(@src());
|
|
return Transpiler__dangerouslySetPtr(value, ptr);
|
|
}
|
|
|
|
/// Detach the ptr from the thisValue
|
|
pub fn detachPtr(_: *Transpiler, value: JSC.JSValue) void {
|
|
JSC.markBinding(@src());
|
|
std.debug.assert(Transpiler__dangerouslySetPtr(value, null));
|
|
}
|
|
|
|
extern fn Transpiler__fromJS(JSC.JSValue) ?*Transpiler;
|
|
extern fn Transpiler__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
|
|
|
|
extern fn Transpiler__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Transpiler) JSC.JSValue;
|
|
|
|
extern fn Transpiler__dangerouslySetPtr(JSC.JSValue, ?*Transpiler) bool;
|
|
|
|
comptime {
|
|
if (@TypeOf(Transpiler.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Transpiler)) {
|
|
@compileLog("Transpiler.constructor is not a constructor");
|
|
}
|
|
|
|
if (@TypeOf(Transpiler.finalize) != (fn (*Transpiler) callconv(.C) void)) {
|
|
@compileLog("Transpiler.finalize is not a finalizer");
|
|
}
|
|
|
|
if (@TypeOf(Transpiler.scan) != CallbackType)
|
|
@compileLog("Expected Transpiler.scan to be a callback but received " ++ @typeName(@TypeOf(Transpiler.scan)));
|
|
if (@TypeOf(Transpiler.scanImports) != CallbackType)
|
|
@compileLog("Expected Transpiler.scanImports to be a callback but received " ++ @typeName(@TypeOf(Transpiler.scanImports)));
|
|
if (@TypeOf(Transpiler.transform) != CallbackType)
|
|
@compileLog("Expected Transpiler.transform to be a callback but received " ++ @typeName(@TypeOf(Transpiler.transform)));
|
|
if (@TypeOf(Transpiler.transformSync) != CallbackType)
|
|
@compileLog("Expected Transpiler.transformSync to be a callback but received " ++ @typeName(@TypeOf(Transpiler.transformSync)));
|
|
if (!JSC.is_bindgen) {
|
|
@export(Transpiler.constructor, .{ .name = "TranspilerClass__construct" });
|
|
@export(Transpiler.finalize, .{ .name = "TranspilerClass__finalize" });
|
|
@export(Transpiler.scan, .{ .name = "TranspilerPrototype__scan" });
|
|
@export(Transpiler.scanImports, .{ .name = "TranspilerPrototype__scanImports" });
|
|
@export(Transpiler.transform, .{ .name = "TranspilerPrototype__transform" });
|
|
@export(Transpiler.transformSync, .{ .name = "TranspilerPrototype__transformSync" });
|
|
}
|
|
}
|
|
};
|
|
|
|
comptime {
|
|
_ = JSBlob;
|
|
_ = JSCryptoHasher;
|
|
_ = JSDirent;
|
|
_ = JSExpect;
|
|
_ = JSFileSystemRouter;
|
|
_ = JSListener;
|
|
_ = JSMD4;
|
|
_ = JSMD5;
|
|
_ = JSMatchedRoute;
|
|
_ = JSNodeJSFS;
|
|
_ = JSRequest;
|
|
_ = JSResponse;
|
|
_ = JSSHA1;
|
|
_ = JSSHA224;
|
|
_ = JSSHA256;
|
|
_ = JSSHA384;
|
|
_ = JSSHA512;
|
|
_ = JSSHA512_256;
|
|
_ = JSServerWebSocket;
|
|
_ = JSStats;
|
|
_ = JSSubprocess;
|
|
_ = JSTCPSocket;
|
|
_ = JSTLSSocket;
|
|
_ = JSTextDecoder;
|
|
_ = JSTranspiler;
|
|
}
|