public/browser
1
0
Fork 0
mirror of https://github.com/lightpanda-io/browser.git synced 2025-10-29 07:03:29 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

use Env.Function instead of Env.Callback

Browse Source
This commit is contained in:
Muki Kiboigo
2025-05-21 11:26:41 -07:00
parent fada732b33
commit 3c3de9d325
13 changed files with 199 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/browser/dom/document.zig
View File

@@ -242,8 +242,8 @@ pub const Document = struct {
return Node.replaceChildren(parser.documentToNode(self), nodes);
}
pub fn _createTreeWalker(_: *parser.Document, root: *parser.Node, what_to_show: ?u32, filter: ?Env.Callback) TreeWalker {
return TreeWalker.init(root, what_to_show, filter);
pub fn _createTreeWalker(_: *parser.Document, root: *parser.Node, what_to_show: ?u32, filter: ?TreeWalker.TreeWalkerOpts) !TreeWalker {
return try TreeWalker.init(root, what_to_show, filter);
}
};

4
src/browser/dom/event_target.zig
View File

@@ -57,7 +57,7 @@ pub const EventTarget = struct {
pub fn _addEventListener(
self: *parser.EventTarget,
typ: []const u8,
cbk: Env.Callback,
cbk: Env.Function,
opts_: ?AddEventListenerOpts,
state: *SessionState,
) !void {
@@ -104,7 +104,7 @@ pub const EventTarget = struct {
pub fn _removeEventListener(
self: *parser.EventTarget,
typ: []const u8,
cbk: Env.Callback,
cbk: Env.Function,
capture: ?bool,
// TODO: hanle EventListenerOptions
// see #https://github.com/lightpanda-io/jsruntime-lib/issues/114

8
src/browser/dom/intersection_observer.zig
View File

@@ -40,7 +40,7 @@ const log = std.log.scoped(.events);
// The returned Entries are phony, they always indicate full intersection.
// https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
pub const IntersectionObserver = struct {
callback: Env.Callback,
callback: Env.Function,
options: IntersectionObserverOptions,
state: *SessionState,
@@ -48,7 +48,7 @@ pub const IntersectionObserver = struct {
// new IntersectionObserver(callback)
// new IntersectionObserver(callback, options) [not supported yet]
pub fn constructor(callback: Env.Callback, options_: ?IntersectionObserverOptions, state: *SessionState) !IntersectionObserver {
pub fn constructor(callback: Env.Function, options_: ?IntersectionObserverOptions, state: *SessionState) !IntersectionObserver {
var options = IntersectionObserverOptions{
.root = parser.documentToNode(parser.documentHTMLToDocument(state.window.document)),
.rootMargin = "0px 0px 0px 0px",
@@ -85,8 +85,8 @@ pub const IntersectionObserver = struct {
.options = &self.options,
});
var result: Env.Callback.Result = undefined;
self.callback.tryCall(.{self.observed_entries.items}, &result) catch {
var result: Env.Function.Result = undefined;
self.callback.tryCall(void, .{self.observed_entries.items}, &result) catch {
log.err("intersection observer callback error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

8
src/browser/dom/mutation_observer.zig
View File

@@ -36,14 +36,14 @@ const log = std.log.scoped(.events);
// WEB IDL https://dom.spec.whatwg.org/#interface-mutationobserver
pub const MutationObserver = struct {
cbk: Env.Callback,
cbk: Env.Function,
arena: Allocator,
// List of records which were observed. When the scopeEnds, we need to
// execute our callback with it.
observed: std.ArrayListUnmanaged(*MutationRecord),
pub fn constructor(cbk: Env.Callback, state: *SessionState) !MutationObserver {
pub fn constructor(cbk: Env.Function, state: *SessionState) !MutationObserver {
return .{
.cbk = cbk,
.observed = .{},
@@ -113,8 +113,8 @@ pub const MutationObserver = struct {
for (record) |r| {
const records = [_]MutationRecord{r.*};
var result: Env.Callback.Result = undefined;
self.cbk.tryCall(.{records}, &result) catch {
var result: Env.Function.Result = undefined;
self.cbk.tryCall(void, .{records}, &result) catch {
log.err("mutation observer callback error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

8
src/browser/dom/nodelist.zig
View File

@@ -21,7 +21,7 @@ const std = @import("std");
const parser = @import("../netsurf.zig");
const JsThis = @import("../env.zig").JsThis;
const Callback = @import("../env.zig").Callback;
const Function = @import("../env.zig").Function;
const NodeUnion = @import("node.zig").Union;
const Node = @import("node.zig").Node;
@@ -141,11 +141,11 @@ pub const NodeList = struct {
// };
// }
pub fn _forEach(self: *NodeList, cbk: Callback) !void { // TODO handle thisArg
pub fn _forEach(self: *NodeList, cbk: Function) !void { // TODO handle thisArg
for (self.nodes.items, 0..) |n, i| {
const ii: u32 = @intCast(i);
var result: Callback.Result = undefined;
cbk.tryCall(.{ n, ii, self }, &result) catch {
var result: Function.Result = undefined;
cbk.tryCall(void, .{ n, ii, self }, &result) catch {
log.err("callback error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

8
src/browser/dom/token_list.zig
View File

@@ -21,7 +21,7 @@ const std = @import("std");
const parser = @import("../netsurf.zig");
const iterator = @import("../iterator/iterator.zig");
const Callback = @import("../env.zig").Callback;
const Function = @import("../env.zig").Function;
const JsObject = @import("../env.zig").JsObject;
const DOMException = @import("exceptions.zig").DOMException;
@@ -138,11 +138,11 @@ pub const DOMTokenList = struct {
}
// TODO handle thisArg
pub fn _forEach(self: *parser.TokenList, cbk: Callback, this_arg: JsObject) !void {
pub fn _forEach(self: *parser.TokenList, cbk: Function, this_arg: JsObject) !void {
var entries = _entries(self);
while (try entries._next()) |entry| {
var result: Callback.Result = undefined;
cbk.tryCallWithThis(this_arg, .{ entry.@"1", entry.@"0", self }, &result) catch {
var result: Function.Result = undefined;
cbk.tryCallWithThis(void, this_arg, .{ entry.@"1", entry.@"0", self }, &result) catch {
log.err("callback error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

143
src/browser/dom/tree_walker.zig
View File

@@ -27,17 +27,63 @@ pub const TreeWalker = struct {
root: *parser.Node,
current_node: *parser.Node,
what_to_show: u32,
filter: ?Env.Callback,
filter: ?Env.Function,
depth: usize,
pub const TreeWalkerOpts = union(enum) {
function: Env.Function,
object: struct { acceptNode: Env.Function },
};
pub fn init(node: *parser.Node, what_to_show: ?u32, filter: ?TreeWalkerOpts) !TreeWalker {
var filter_func: ?Env.Function = null;
if (filter) |f| {
filter_func = switch (f) {
.function => |func| func,
.object => |o| o.acceptNode,
};
}
pub fn init(node: *parser.Node, what_to_show: ?u32, filter: ?Env.Callback) TreeWalker {
return .{
.root = node,
.current_node = node,
.what_to_show = what_to_show orelse NodeFilter._SHOW_ALL,
.filter = filter,
.filter = filter_func,
.depth = 0,
};
}
fn verify_what_to_show(self: *const TreeWalker, node: *parser.Node) !bool {
const node_type = try parser.nodeType(node);
const what_to_show = self.what_to_show;
return switch (node_type) {
.attribute => what_to_show & NodeFilter._SHOW_ATTRIBUTE != 0,
.cdata_section => what_to_show & NodeFilter._SHOW_CDATA_SECTION != 0,
.comment => what_to_show & NodeFilter._SHOW_COMMENT != 0,
.document => what_to_show & NodeFilter._SHOW_DOCUMENT != 0,
.document_fragment => what_to_show & NodeFilter._SHOW_DOCUMENT_FRAGMENT != 0,
.document_type => what_to_show & NodeFilter._SHOW_DOCUMENT_TYPE != 0,
.element => what_to_show & NodeFilter._SHOW_ELEMENT != 0,
.entity => what_to_show & NodeFilter._SHOW_ENTITY != 0,
.entity_reference => what_to_show & NodeFilter._SHOW_ENTITY_REFERENCE != 0,
.notation => what_to_show & NodeFilter._SHOW_NOTATION != 0,
.processing_instruction => what_to_show & NodeFilter._SHOW_PROCESSING_INSTRUCTION != 0,
.text => what_to_show & NodeFilter._SHOW_TEXT != 0,
};
}
fn verify_filter(self: *const TreeWalker, node: *parser.Node) !bool {
if (self.filter) |f| {
const filter = try f.call(u32, .{node});
return switch (filter) {
NodeFilter._FILTER_ACCEPT => true,
else => false,
};
} else return true;
}
pub fn get_root(self: *TreeWalker) *parser.Node {
return self.root;
}
@@ -50,45 +96,92 @@ pub const TreeWalker = struct {
return self.what_to_show;
}
pub fn get_filter(self: *TreeWalker) ?Env.Callback {
pub fn get_filter(self: *TreeWalker) ?Env.Function {
return self.filter;
}
pub fn _firstChild(self: *TreeWalker) ?*parser.Node {
const first_child = parser.nodeFirstChild(self.current_node) catch return null;
self.current_node = first_child orelse return null;
return first_child;
pub fn _firstChild(self: *TreeWalker) !?*parser.Node {
const children = try parser.nodeGetChildNodes(self.current_node);
const child_count = try parser.nodeListLength(children);
for (0..child_count) |i| {
const index: u32 = @intCast(i);
const child = (try parser.nodeListItem(children, index)) orelse return null;
if (!try self.verify_what_to_show(child)) continue;
if (!try self.verify_filter(child)) continue;
self.depth += 1;
self.current_node = child;
return child;
}
return null;
}
pub fn _lastChild(self: *TreeWalker) ?*parser.Node {
const last_child = parser.nodeLastChild(self.current_node) catch return null;
self.current_node = last_child orelse return null;
return last_child;
pub fn _lastChild(self: *TreeWalker) !?*parser.Node {
const children = try parser.nodeGetChildNodes(self.current_node);
const child_count = try parser.nodeListLength(children);
for (0..child_count) |i| {
const index: u32 = @intCast(child_count - 1 - i);
const child = (try parser.nodeListItem(children, index)) orelse return null;
if (!try self.verify_what_to_show(child)) continue;
if (!try self.verify_filter(child)) continue;
self.depth += 1;
self.current_node = child;
return child;
}
return null;
}
pub fn _nextNode(self: *TreeWalker) ?*parser.Node {
pub fn _nextNode(self: *TreeWalker) !?*parser.Node {
return self._firstChild();
}
pub fn _nextSibling(self: *TreeWalker) ?*parser.Node {
const next_sibling = parser.nodeNextSibling(self.current_node) catch return null;
self.current_node = next_sibling orelse return null;
return next_sibling;
pub fn _nextSibling(self: *TreeWalker) !?*parser.Node {
var current = self.current_node;
while (true) {
current = (try parser.nodeNextSibling(current)) orelse return null;
if (!try self.verify_what_to_show(current)) continue;
if (!try self.verify_filter(current)) continue;
break;
}
return current;
}
pub fn _parentNode(self: *TreeWalker) ?*parser.Node {
const parent = parser.nodeParentNode(self.current_node) catch return null;
self.current_node = parent orelse return null;
pub fn _parentNode(self: *TreeWalker) !?*parser.Node {
if (self.depth == 0) return null;
const parent = (try parser.nodeParentNode(self.current_node)) orelse return null;
if (!try self.verify_what_to_show(parent)) return null;
if (!try self.verify_filter(parent)) return null;
self.depth -= 1;
self.current_node = parent;
return parent;
}
pub fn _previousNode(self: *TreeWalker) ?*parser.Node {
pub fn _previousNode(self: *TreeWalker) !?*parser.Node {
return self._parentNode();
}
pub fn _previousSibling(self: *TreeWalker) ?*parser.Node {
const previous_sibling = parser.nodePreviousSibling(self.current_node) catch return null;
self.current_node = previous_sibling orelse return null;
return previous_sibling;
pub fn _previousSibling(self: *TreeWalker) !?*parser.Node {
var current = self.current_node;
while (true) {
current = (try parser.nodePreviousSibling(current)) orelse return null;
if (!try self.verify_what_to_show(current)) continue;
if (!try self.verify_filter(current)) continue;
break;
}
return current;
}
};

2
src/browser/env.zig
View File

@@ -42,7 +42,7 @@ const WebApis = struct {
pub const JsThis = Env.JsThis;
pub const JsObject = Env.JsObject;
pub const Callback = Env.Callback;
pub const Function = Env.Function;
pub const Env = js.Env(*SessionState, WebApis);
const Window = @import("html/window.zig").Window;

10
src/browser/events/event.zig
View File

@@ -20,7 +20,7 @@ const std = @import("std");
const Allocator = std.mem.Allocator;
const parser = @import("../netsurf.zig");
const Callback = @import("../env.zig").Callback;
const Function = @import("../env.zig").Function;
const generate = @import("../../runtime/generate.zig");
const DOMException = @import("../dom/exceptions.zig").DOMException;
@@ -140,10 +140,10 @@ pub const Event = struct {
};
pub const EventHandler = struct {
callback: Callback,
callback: Function,
node: parser.EventNode,
pub fn init(allocator: Allocator, callback: Callback) !*EventHandler {
pub fn init(allocator: Allocator, callback: Function) !*EventHandler {
const eh = try allocator.create(EventHandler);
eh.* = .{
.callback = callback,
@@ -162,8 +162,8 @@ pub const EventHandler = struct {
};
const self: *EventHandler = @fieldParentPtr("node", node);
var result: Callback.Result = undefined;
self.callback.tryCall(.{ievent}, &result) catch {
var result: Function.Result = undefined;
self.callback.tryCall(void, .{ievent}, &result) catch {
log.err("event handler error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

6
src/browser/html/media_query_list.zig
View File

@@ -17,7 +17,7 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
const parser = @import("../netsurf.zig");
const Callback = @import("../env.zig").Callback;
const Function = @import("../env.zig").Function;
const EventTarget = @import("../dom/event_target.zig").EventTarget;
// https://drafts.csswg.org/cssom-view/#the-mediaquerylist-interface
@@ -39,7 +39,7 @@ pub const MediaQueryList = struct {
return self.media;
}
pub fn _addListener(_: *const MediaQueryList, _: Callback) void {}
pub fn _addListener(_: *const MediaQueryList, _: Function) void {}
pub fn _removeListener(_: *const MediaQueryList, _: Callback) void {}
pub fn _removeListener(_: *const MediaQueryList, _: Function) void {}
};

20
src/browser/html/window.zig
View File

@@ -19,7 +19,7 @@
const std = @import("std");
const parser = @import("../netsurf.zig");
const Callback = @import("../env.zig").Callback;
const Function = @import("../env.zig").Function;
const SessionState = @import("../env.zig").SessionState;
const Loop = @import("../../runtime/loop.zig").Loop;
@@ -159,12 +159,12 @@ pub const Window = struct {
// Returns the request ID, that uniquely identifies the entry in the callback list.
pub fn _requestAnimationFrame(
self: *Window,
callback: Callback,
callback: Function,
) !u32 {
// We immediately execute the callback, but this may not be correct TBD.
// Since: When multiple callbacks queued by requestAnimationFrame() begin to fire in a single frame, each receives the same timestamp even though time has passed during the computation of every previous callback's workload.
var result: Callback.Result = undefined;
callback.tryCall(.{self.performance._now()}, &result) catch {
var result: Function.Result = undefined;
callback.tryCall(void, .{self.performance._now()}, &result) catch {
log.err("Window.requestAnimationFrame(): {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};
@@ -178,12 +178,12 @@ pub const Window = struct {
}
// TODO handle callback arguments.
pub fn _setTimeout(self: *Window, cbk: Callback, delay: ?u32, state: *SessionState) !u32 {
pub fn _setTimeout(self: *Window, cbk: Function, delay: ?u32, state: *SessionState) !u32 {
return self.createTimeout(cbk, delay, state, false);
}
// TODO handle callback arguments.
pub fn _setInterval(self: *Window, cbk: Callback, delay: ?u32, state: *SessionState) !u32 {
pub fn _setInterval(self: *Window, cbk: Function, delay: ?u32, state: *SessionState) !u32 {
return self.createTimeout(cbk, delay, state, true);
}
@@ -204,7 +204,7 @@ pub const Window = struct {
};
}
fn createTimeout(self: *Window, cbk: Callback, delay_: ?u32, state: *SessionState, comptime repeat: bool) !u32 {
fn createTimeout(self: *Window, cbk: Function, delay_: ?u32, state: *SessionState, comptime repeat: bool) !u32 {
if (self.timers.count() > 512) {
return error.TooManyTimeout;
}
@@ -255,7 +255,7 @@ const TimerCallback = struct {
timer_id: u31,
// The JavaScript callback to execute
cbk: Callback,
cbk: Function,
// This is the internal data that the event loop tracks. We'll get this
// back in run and, from it, can get our TimerCallback instance
@@ -269,8 +269,8 @@ const TimerCallback = struct {
fn run(node: *Loop.CallbackNode, repeat_delay: *?u63) void {
const self: *TimerCallback = @fieldParentPtr("node", node);
var result: Callback.Result = undefined;
self.cbk.tryCall(.{}, &result) catch {
var result: Function.Result = undefined;
self.cbk.tryCall(void, .{}, &result) catch {
log.err("timeout callback error: {s}", .{result.exception});
log.debug("stack:\n{s}", .{result.stack orelse "???"});
};

40
src/browser/xhr/event_target.zig
View File

@@ -19,7 +19,7 @@
const std = @import("std");
const Env = @import("../env.zig").Env;
const Callback = Env.Callback;
const Function = Env.Function;
const EventTarget = @import("../dom/event_target.zig").EventTarget;
const EventHandler = @import("../events/event.zig").EventHandler;
@@ -35,18 +35,18 @@ pub const XMLHttpRequestEventTarget = struct {
// Extend libdom event target for pure zig struct.
base: parser.EventTargetTBase = parser.EventTargetTBase{},
onloadstart_cbk: ?Callback = null,
onprogress_cbk: ?Callback = null,
onabort_cbk: ?Callback = null,
onload_cbk: ?Callback = null,
ontimeout_cbk: ?Callback = null,
onloadend_cbk: ?Callback = null,
onloadstart_cbk: ?Function = null,
onprogress_cbk: ?Function = null,
onabort_cbk: ?Function = null,
onload_cbk: ?Function = null,
ontimeout_cbk: ?Function = null,
onloadend_cbk: ?Function = null,
fn register(
self: *XMLHttpRequestEventTarget,
alloc: std.mem.Allocator,
typ: []const u8,
cbk: Callback,
cbk: Function,
) !void {
const target = @as(*parser.EventTarget, @ptrCast(self));
const eh = try EventHandler.init(alloc, try cbk.withThis(target));
@@ -69,51 +69,51 @@ pub const XMLHttpRequestEventTarget = struct {
try parser.eventTargetRemoveEventListener(et, typ, lst.?, false);
}
pub fn get_onloadstart(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_onloadstart(self: *XMLHttpRequestEventTarget) ?Function {
return self.onloadstart_cbk;
}
pub fn get_onprogress(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_onprogress(self: *XMLHttpRequestEventTarget) ?Function {
return self.onprogress_cbk;
}
pub fn get_onabort(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_onabort(self: *XMLHttpRequestEventTarget) ?Function {
return self.onabort_cbk;
}
pub fn get_onload(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_onload(self: *XMLHttpRequestEventTarget) ?Function {
return self.onload_cbk;
}
pub fn get_ontimeout(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_ontimeout(self: *XMLHttpRequestEventTarget) ?Function {
return self.ontimeout_cbk;
}
pub fn get_onloadend(self: *XMLHttpRequestEventTarget) ?Callback {
pub fn get_onloadend(self: *XMLHttpRequestEventTarget) ?Function {
return self.onloadend_cbk;
}
pub fn set_onloadstart(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_onloadstart(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.onloadstart_cbk) |cbk| try self.unregister("loadstart", cbk.id);
try self.register(state.arena, "loadstart", handler);
self.onloadstart_cbk = handler;
}
pub fn set_onprogress(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_onprogress(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.onprogress_cbk) |cbk| try self.unregister("progress", cbk.id);
try self.register(state.arena, "progress", handler);
self.onprogress_cbk = handler;
}
pub fn set_onabort(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_onabort(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.onabort_cbk) |cbk| try self.unregister("abort", cbk.id);
try self.register(state.arena, "abort", handler);
self.onabort_cbk = handler;
}
pub fn set_onload(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_onload(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.onload_cbk) |cbk| try self.unregister("load", cbk.id);
try self.register(state.arena, "load", handler);
self.onload_cbk = handler;
}
pub fn set_ontimeout(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_ontimeout(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.ontimeout_cbk) |cbk| try self.unregister("timeout", cbk.id);
try self.register(state.arena, "timeout", handler);
self.ontimeout_cbk = handler;
}
pub fn set_onloadend(self: *XMLHttpRequestEventTarget, handler: Callback, state: *SessionState) !void {
pub fn set_onloadend(self: *XMLHttpRequestEventTarget, handler: Function, state: *SessionState) !void {
if (self.onloadend_cbk) |cbk| try self.unregister("loadend", cbk.id);
try self.register(state.arena, "loadend", handler);
self.onloadend_cbk = handler;

40
src/runtime/js.zig
View File

@@ -947,7 +947,7 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
// Extracted so that it can be used in both jsValueToZig and in
// probeJsValueToZig. Avoids having to duplicate this logic when probing.
fn jsValueToStruct(self: *Scope, comptime named_function: NamedFunction, comptime T: type, js_value: v8.Value) !?T {
if (@hasDecl(T, "_CALLBACK_ID_KLUDGE")) {
if (@hasDecl(T, "_FUNCTION_ID_KLUDGE")) {
if (!js_value.isFunction()) {
return error.InvalidArgument;
}
@@ -1218,25 +1218,25 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
}
};
pub const Callback = struct {
pub const Function = struct {
id: usize,
scope: *Scope,
this: ?v8.Object = null,
func: PersistentFunction,
// We use this when mapping a JS value to a Zig object. We can't
// Say we have a Zig function that takes a Callback, we can't just
// check param.type == Callback, because Callback is a generic.
// Say we have a Zig function that takes a Function, we can't just
// check param.type == Function, because Function is a generic.
// So, as a quick hack, we can determine if the Zig type is a
// callback by checking @hasDecl(T, "_CALLBACK_ID_KLUDGE")
const _CALLBACK_ID_KLUDGE = true;
// callback by checking @hasDecl(T, "_FUNCTION_ID_KLUDGE")
const _FUNCTION_ID_KLUDGE = true;
pub const Result = struct {
stack: ?[]const u8,
exception: []const u8,
};
pub fn withThis(self: *const Callback, value: anytype) !Callback {
pub fn withThis(self: *const Function, value: anytype) !Function {
return .{
.id = self.id,
.func = self.func,
@@ -1245,20 +1245,20 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
};
}
pub fn call(self: *const Callback, args: anytype) !void {
return self.callWithThis(self.getThis(), args);
pub fn call(self: *const Function, comptime T: type, args: anytype) !T {
return self.callWithThis(T, self.getThis(), args);
}
pub fn tryCall(self: *const Callback, args: anytype, result: *Result) !void {
return self.tryCallWithThis(self.getThis(), args, result);
pub fn tryCall(self: *const Function, comptime T: type, args: anytype, result: *Result) !T {
return self.tryCallWithThis(T, self.getThis(), args, result);
}
pub fn tryCallWithThis(self: *const Callback, this: anytype, args: anytype, result: *Result) !void {
pub fn tryCallWithThis(self: *const Function, comptime T: type, this: anytype, args: anytype, result: *Result) !void {
var try_catch: TryCatch = undefined;
try_catch.init(self.scope);
defer try_catch.deinit();
self.callWithThis(this, args) catch |err| {
return self.callWithThis(T, this, args) catch |err| {
if (try_catch.hasCaught()) {
const allocator = self.scope.call_arena;
result.stack = try_catch.stack(allocator) catch null;
@@ -1271,7 +1271,7 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
};
}
pub fn callWithThis(self: *const Callback, this: anytype, args: anytype) !void {
pub fn callWithThis(self: *const Function, comptime T: type, this: anytype, args: anytype) !T {
const scope = self.scope;
const js_this = try scope.valueToExistingObject(this);
@@ -1287,14 +1287,18 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
if (result == null) {
return error.JSExecCallback;
}
if (@typeInfo(T) == .void) return {};
const named_function = comptime NamedFunction.init(T, "callResult");
return scope.jsValueToZig(named_function, T, result.?);
}
fn getThis(self: *const Callback) v8.Object {
fn getThis(self: *const Function) v8.Object {
return self.this orelse self.scope.context.getGlobal();
}
// debug/helper to print the source of the JS callback
pub fn printFunc(self: Callback) !void {
pub fn printFunc(self: Function) !void {
const scope = self.scope;
const value = self.func.castToFunction().toValue();
const src = try valueToString(scope.call_arena, value, scope.isolate, scope.context);
@@ -1453,7 +1457,7 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
// Env.JsObject. Want a TypedArray? Env.TypedArray.
pub fn TypedArray(comptime T: type) type {
return struct {
// See Callback._CALLBACK_ID_KLUDGE
// See Function._FUNCTION_ID_KLUDGE
const _TYPED_ARRAY_ID_KLUDGE = true;
values: []const T,
@@ -1987,7 +1991,7 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
return js_obj.toValue();
}
if (T == Callback) {
if (T == Function) {
// we're returnig a callback
return value.func.toValue();
}