diff options
Diffstat (limited to 'src/bun.js/bindings/generated_classes.zig')
| -rw-r--r-- | src/bun.js/bindings/generated_classes.zig | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/src/bun.js/bindings/generated_classes.zig b/src/bun.js/bindings/generated_classes.zig index a4bbd2cab..b98d59cd3 100644 --- a/src/bun.js/bindings/generated_classes.zig +++ b/src/bun.js/bindings/generated_classes.zig @@ -1176,6 +1176,227 @@ pub const JSExpectAny = struct { } } }; +pub const JSExpectAnything = struct { + const ExpectAnything = Classes.ExpectAnything; + const GetterType = fn (*ExpectAnything, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const GetterTypeWithThisValue = fn (*ExpectAnything, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const SetterType = fn (*ExpectAnything, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const SetterTypeWithThisValue = fn (*ExpectAnything, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const CallbackType = fn (*ExpectAnything, *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) ?*ExpectAnything { + JSC.markBinding(@src()); + return ExpectAnything__fromJS(value); + } + + /// Create a new instance of ExpectAnything + pub fn toJS(this: *ExpectAnything, globalObject: *JSC.JSGlobalObject) JSC.JSValue { + JSC.markBinding(@src()); + if (comptime Environment.allow_assert) { + const value__ = ExpectAnything__create(globalObject, this); + std.debug.assert(value__.as(ExpectAnything).? == this); // If this fails, likely a C ABI issue. + return value__; + } else { + return ExpectAnything__create(globalObject, this); + } + } + + /// Modify the internal ptr to point to a new instance of ExpectAnything. + pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*ExpectAnything) bool { + JSC.markBinding(@src()); + return ExpectAnything__dangerouslySetPtr(value, ptr); + } + + /// Detach the ptr from the thisValue + pub fn detachPtr(_: *ExpectAnything, value: JSC.JSValue) void { + JSC.markBinding(@src()); + std.debug.assert(ExpectAnything__dangerouslySetPtr(value, null)); + } + + extern fn ExpectAnything__fromJS(JSC.JSValue) ?*ExpectAnything; + extern fn ExpectAnything__getConstructor(*JSC.JSGlobalObject) JSC.JSValue; + + extern fn ExpectAnything__create(globalObject: *JSC.JSGlobalObject, ptr: ?*ExpectAnything) JSC.JSValue; + + extern fn ExpectAnything__dangerouslySetPtr(JSC.JSValue, ?*ExpectAnything) bool; + + comptime { + if (@TypeOf(ExpectAnything.finalize) != (fn (*ExpectAnything) callconv(.C) void)) { + @compileLog("ExpectAnything.finalize is not a finalizer"); + } + + if (@TypeOf(ExpectAnything.call) != StaticCallbackType) + @compileLog("Expected ExpectAnything.call to be a static callback"); + if (!JSC.is_bindgen) { + @export(ExpectAnything.call, .{ .name = "ExpectAnythingClass__call" }); + @export(ExpectAnything.finalize, .{ .name = "ExpectAnythingClass__finalize" }); + } + } +}; +pub const JSExpectStringContaining = struct { + const ExpectStringContaining = Classes.ExpectStringContaining; + const GetterType = fn (*ExpectStringContaining, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const GetterTypeWithThisValue = fn (*ExpectStringContaining, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const SetterType = fn (*ExpectStringContaining, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const SetterTypeWithThisValue = fn (*ExpectStringContaining, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const CallbackType = fn (*ExpectStringContaining, *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) ?*ExpectStringContaining { + JSC.markBinding(@src()); + return ExpectStringContaining__fromJS(value); + } + + extern fn ExpectStringContainingPrototype__stringValueSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void; + + extern fn ExpectStringContainingPrototype__stringValueGetCachedValue(JSC.JSValue) JSC.JSValue; + + /// `ExpectStringContaining.stringValue` setter + /// This value will be visited by the garbage collector. + pub fn stringValueSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void { + JSC.markBinding(@src()); + ExpectStringContainingPrototype__stringValueSetCachedValue(thisValue, globalObject, value); + } + + /// `ExpectStringContaining.stringValue` getter + /// This value will be visited by the garbage collector. + pub fn stringValueGetCached(thisValue: JSC.JSValue) ?JSC.JSValue { + JSC.markBinding(@src()); + const result = ExpectStringContainingPrototype__stringValueGetCachedValue(thisValue); + if (result == .zero) + return null; + + return result; + } + + /// Create a new instance of ExpectStringContaining + pub fn toJS(this: *ExpectStringContaining, globalObject: *JSC.JSGlobalObject) JSC.JSValue { + JSC.markBinding(@src()); + if (comptime Environment.allow_assert) { + const value__ = ExpectStringContaining__create(globalObject, this); + std.debug.assert(value__.as(ExpectStringContaining).? == this); // If this fails, likely a C ABI issue. + return value__; + } else { + return ExpectStringContaining__create(globalObject, this); + } + } + + /// Modify the internal ptr to point to a new instance of ExpectStringContaining. + pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*ExpectStringContaining) bool { + JSC.markBinding(@src()); + return ExpectStringContaining__dangerouslySetPtr(value, ptr); + } + + /// Detach the ptr from the thisValue + pub fn detachPtr(_: *ExpectStringContaining, value: JSC.JSValue) void { + JSC.markBinding(@src()); + std.debug.assert(ExpectStringContaining__dangerouslySetPtr(value, null)); + } + + extern fn ExpectStringContaining__fromJS(JSC.JSValue) ?*ExpectStringContaining; + extern fn ExpectStringContaining__getConstructor(*JSC.JSGlobalObject) JSC.JSValue; + + extern fn ExpectStringContaining__create(globalObject: *JSC.JSGlobalObject, ptr: ?*ExpectStringContaining) JSC.JSValue; + + extern fn ExpectStringContaining__dangerouslySetPtr(JSC.JSValue, ?*ExpectStringContaining) bool; + + comptime { + if (@TypeOf(ExpectStringContaining.finalize) != (fn (*ExpectStringContaining) callconv(.C) void)) { + @compileLog("ExpectStringContaining.finalize is not a finalizer"); + } + + if (@TypeOf(ExpectStringContaining.call) != StaticCallbackType) + @compileLog("Expected ExpectStringContaining.call to be a static callback"); + if (!JSC.is_bindgen) { + @export(ExpectStringContaining.call, .{ .name = "ExpectStringContainingClass__call" }); + @export(ExpectStringContaining.finalize, .{ .name = "ExpectStringContainingClass__finalize" }); + } + } +}; +pub const JSExpectStringMatching = struct { + const ExpectStringMatching = Classes.ExpectStringMatching; + const GetterType = fn (*ExpectStringMatching, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const GetterTypeWithThisValue = fn (*ExpectStringMatching, JSC.JSValue, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; + const SetterType = fn (*ExpectStringMatching, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const SetterTypeWithThisValue = fn (*ExpectStringMatching, JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool; + const CallbackType = fn (*ExpectStringMatching, *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) ?*ExpectStringMatching { + JSC.markBinding(@src()); + return ExpectStringMatching__fromJS(value); + } + + extern fn ExpectStringMatchingPrototype__testValueSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void; + + extern fn ExpectStringMatchingPrototype__testValueGetCachedValue(JSC.JSValue) JSC.JSValue; + + /// `ExpectStringMatching.testValue` setter + /// This value will be visited by the garbage collector. + pub fn testValueSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void { + JSC.markBinding(@src()); + ExpectStringMatchingPrototype__testValueSetCachedValue(thisValue, globalObject, value); + } + + /// `ExpectStringMatching.testValue` getter + /// This value will be visited by the garbage collector. + pub fn testValueGetCached(thisValue: JSC.JSValue) ?JSC.JSValue { + JSC.markBinding(@src()); + const result = ExpectStringMatchingPrototype__testValueGetCachedValue(thisValue); + if (result == .zero) + return null; + + return result; + } + + /// Create a new instance of ExpectStringMatching + pub fn toJS(this: *ExpectStringMatching, globalObject: *JSC.JSGlobalObject) JSC.JSValue { + JSC.markBinding(@src()); + if (comptime Environment.allow_assert) { + const value__ = ExpectStringMatching__create(globalObject, this); + std.debug.assert(value__.as(ExpectStringMatching).? == this); // If this fails, likely a C ABI issue. + return value__; + } else { + return ExpectStringMatching__create(globalObject, this); + } + } + + /// Modify the internal ptr to point to a new instance of ExpectStringMatching. + pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*ExpectStringMatching) bool { + JSC.markBinding(@src()); + return ExpectStringMatching__dangerouslySetPtr(value, ptr); + } + + /// Detach the ptr from the thisValue + pub fn detachPtr(_: *ExpectStringMatching, value: JSC.JSValue) void { + JSC.markBinding(@src()); + std.debug.assert(ExpectStringMatching__dangerouslySetPtr(value, null)); + } + + extern fn ExpectStringMatching__fromJS(JSC.JSValue) ?*ExpectStringMatching; + extern fn ExpectStringMatching__getConstructor(*JSC.JSGlobalObject) JSC.JSValue; + + extern fn ExpectStringMatching__create(globalObject: *JSC.JSGlobalObject, ptr: ?*ExpectStringMatching) JSC.JSValue; + + extern fn ExpectStringMatching__dangerouslySetPtr(JSC.JSValue, ?*ExpectStringMatching) bool; + + comptime { + if (@TypeOf(ExpectStringMatching.finalize) != (fn (*ExpectStringMatching) callconv(.C) void)) { + @compileLog("ExpectStringMatching.finalize is not a finalizer"); + } + + if (@TypeOf(ExpectStringMatching.call) != StaticCallbackType) + @compileLog("Expected ExpectStringMatching.call to be a static callback"); + if (!JSC.is_bindgen) { + @export(ExpectStringMatching.call, .{ .name = "ExpectStringMatchingClass__call" }); + @export(ExpectStringMatching.finalize, .{ .name = "ExpectStringMatchingClass__finalize" }); + } + } +}; pub const JSFileSystemRouter = struct { const FileSystemRouter = Classes.FileSystemRouter; const GetterType = fn (*FileSystemRouter, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue; @@ -4622,6 +4843,9 @@ comptime { _ = JSDirent; _ = JSExpect; _ = JSExpectAny; + _ = JSExpectAnything; + _ = JSExpectStringContaining; + _ = JSExpectStringMatching; _ = JSFileSystemRouter; _ = JSListener; _ = JSMD4; |