public/browser
1
0
Fork 0
mirror of https://github.com/lightpanda-io/browser.git synced 2026-02-04 14:33:47 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

migrate almost all types

Browse Source
This commit is contained in:
Karl Seguin
2026-01-02 14:52:44 +08:00
parent bc11a48e6b
commit 18c846757b
24 changed files with 884 additions and 869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/browser/js/Array.zig
View File

@@ -43,7 +43,24 @@ pub fn get(self: Array, index: u32) !js.Value {
};
}
pub fn asObject(self: Array) js.Object {
pub fn set(self: Array, index: u32, value: anytype, comptime opts: js.bridge.Caller.CallOpts) !bool {
const ctx = self.ctx;
const js_value = try ctx.zigValueToJs(value, opts);
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__SetAtIndex(@ptrCast(self.handle), ctx.handle, index, js_value.handle, &out);
return out.has_value;
}
pub fn toObject(self: Array) js.Object {
return .{
.ctx = self.ctx,
.handle = @ptrCast(self.handle),
};
}
pub fn toValue(self: Array) js.Value {
return .{
.ctx = self.ctx,
.handle = @ptrCast(self.handle),

23
src/browser/js/BigInt.zig
View File

@@ -23,26 +23,23 @@ const BigInt = @This();
handle: *const v8.c.Integer,
pub fn initI64(isolate_handle: *v8.c.Isolate, val: i64) BigInt {
return .{
.handle = v8.c.v8__BigInt__New(isolate_handle, val).?,
pub fn init(isolate: *v8.c.Isolate, val: anytype) BigInt {
const handle = switch (@TypeOf(val)) {
i8, i16, i32, i64, isize => v8.c.v8__BigInt__New(isolate, val).?,
u8, u16, u32, u64, usize => v8.c.v8__BigInt__NewFromUnsigned(isolate, val).?,
else => |T| @compileError("cannot create v8::BigInt from: " ++ @typeName(T)),
};
}
pub fn initU64(isolate_handle: *v8.c.Isolate, val: u64) BigInt {
return .{
.handle = v8.c.v8__BigInt__NewFromUnsigned(isolate_handle, val).?,
};
}
pub fn getUint64(self: BigInt) u64 {
return v8.c.v8__BigInt__Uint64Value(self.handle, null);
return .{ .handle = handle };
}
pub fn getInt64(self: BigInt) i64 {
return v8.c.v8__BigInt__Int64Value(self.handle, null);
}
pub fn getUint64(self: BigInt) u64 {
return v8.c.v8__BigInt__Uint64Value(self.handle, null);
}
pub fn toValue(self: BigInt) js.Value {
return .{
.ctx = undefined, // Will be set by caller if needed

659
src/browser/js/Context.zig
View File

File diff suppressed because it is too large Load Diff

2
src/browser/js/ExecutionWorld.zig
View File

@@ -137,7 +137,7 @@ pub fn createContext(self: *ExecutionWorld, page: *Page, enter: bool) !*Context
var context = &self.context.?;
// Store a pointer to our context inside the v8 context so that, given
// a v8 context, we can get our context out
const data = isolate.initBigIntU64(@intCast(@intFromPtr(context)));
const data = isolate.initBigInt(@intFromPtr(context));
v8.c.v8__Context__SetEmbedderData(context_handle, 1, @ptrCast(data.handle));
try context.setupGlobal();

10
src/browser/js/Function.zig
View File

@@ -107,7 +107,6 @@ pub fn tryCallWithThis(self: *const Function, comptime T: type, this: anytype, a
pub fn callWithThis(self: *const Function, comptime T: type, this: anytype, args: anytype) !T {
const ctx = self.ctx;
<<<<<<< HEAD
// When we're calling a function from within JavaScript itself, this isn't
// necessary. We're within a Caller instantiation, which will already have
// incremented the call_depth and it won't decrement it until the Caller is
@@ -122,10 +121,6 @@ pub fn callWithThis(self: *const Function, comptime T: type, this: anytype, args
defer context.call_depth = call_depth;
const js_this = blk: {
if (@TypeOf(this) == v8.Object) {
break :blk this;
}
if (@TypeOf(this) == js.Object) {
break :blk this.js_obj;
}
@@ -180,9 +175,8 @@ pub fn src(self: *const Function) ![]const u8 {
pub fn getPropertyValue(self: *const Function, name: []const u8) !?js.Value {
const ctx = self.ctx;
const v8_isolate = v8.Isolate{ .handle = ctx.isolate.handle };
const key = v8.String.initUtf8(v8_isolate, name);
const handle = v8.c.v8__Object__Get(self.handle, ctx.handle, key.handle) orelse {
const key = ctx.isolate.initStringHandle(name);
const handle = v8.c.v8__Object__Get(self.handle, ctx.handle, key) orelse {
return error.JsException;
};

51
src/browser/js/Isolate.zig
View File

@@ -46,8 +46,7 @@ pub fn performMicrotasksCheckpoint(self: Isolate) void {
}
pub fn enqueueMicrotask(self: Isolate, callback: anytype, data: anytype) void {
const v8_isolate = v8.Isolate{ .handle = self.handle };
v8_isolate.enqueueMicrotask(callback, data);
v8.c.v8__Isolate__EnqueueMicrotask(self.handle, callback, data);
}
pub fn enqueueMicrotaskFunc(self: Isolate, function: js.Function) void {
@@ -68,40 +67,46 @@ pub fn throwException(self: Isolate, value: *const v8.c.Value) *const v8.c.Value
return v8.c.v8__Isolate__ThrowException(self.handle, value).?;
}
pub fn createStringHandle(self: Isolate, str: []const u8) *const v8.c.String {
pub fn initStringHandle(self: Isolate, str: []const u8) *const v8.c.String {
return v8.c.v8__String__NewFromUtf8(self.handle, str.ptr, v8.c.kNormal, @as(c_int, @intCast(str.len))).?;
}
pub fn createError(self: Isolate, msg: []const u8) *const v8.c.Value {
const message = self.createStringHandle(msg);
const message = self.initStringHandle(msg);
return v8.c.v8__Exception__Error(message).?;
}
pub fn createTypeError(self: Isolate, msg: []const u8) *const v8.c.Value {
const message = self.createStringHandle(msg);
const message = self.initStringHandle(msg);
return v8.c.v8__Exception__TypeError(message).?;
}
pub fn initArray(self: Isolate, len: u32) v8.Array {
const handle = v8.c.v8__Array__New(self.handle, @intCast(len)).?;
return .{ .handle = handle };
}
pub fn initObject(self: Isolate) v8.Object {
const handle = v8.c.v8__Object__New(self.handle).?;
return .{ .handle = handle };
}
pub fn initString(self: Isolate, str: []const u8) v8.String {
return .{ .handle = self.createStringHandle(str) };
}
pub fn initNull(self: Isolate) *const v8.c.Value {
return v8.c.v8__Null(self.handle).?;
}
pub fn initBigIntU64(self: Isolate, val: u64) js.BigInt {
return js.BigInt.initU64(self.handle, val);
pub fn initUndefined(self: Isolate) *const v8.c.Value {
return v8.c.v8__Undefined(self.handle).?;
}
pub fn initFalse(self: Isolate) *const v8.c.Value {
return v8.c.v8__False(self.handle).?;
}
pub fn initTrue(self: Isolate) *const v8.c.Value {
return v8.c.v8__True(self.handle).?;
}
pub fn initInteger(self: Isolate, val: anytype) js.Integer {
return js.Integer.init(self.handle, val);
}
pub fn initBigInt(self: Isolate, val: anytype) js.BigInt {
return js.BigInt.init(self.handle, val);
}
pub fn initNumber(self: Isolate, val: anytype) js.Number {
return js.Number.init(self.handle, val);
}
pub fn createContextHandle(self: Isolate, global_tmpl: ?*const v8.c.ObjectTemplate, global_obj: ?*const v8.c.Value) *const v8.c.Context {
@@ -111,3 +116,7 @@ pub fn createContextHandle(self: Isolate, global_tmpl: ?*const v8.c.ObjectTempla
pub fn createFunctionTemplateHandle(self: Isolate) *const v8.c.FunctionTemplate {
return v8.c.v8__FunctionTemplate__New__DEFAULT(self.handle).?;
}
pub fn createExternal(self: Isolate, val: *anyopaque) *const v8.c.External {
return v8.c.v8__External__New(self.handle, val).?;
}

61
src/browser/js/Module.zig
View File

@@ -21,6 +21,9 @@ const v8 = js.v8;
const Module = @This();
ctx: *js.Context,
handle: *const v8.c.Module,
pub const Status = enum(u32) {
kUninstantiated = v8.c.kUninstantiated,
kInstantiating = v8.c.kInstantiating,
@@ -30,49 +33,54 @@ pub const Status = enum(u32) {
kErrored = v8.c.kErrored,
};
handle: *const v8.c.Module,
pub fn getStatus(self: Module) Status {
return @enumFromInt(v8.c.v8__Module__GetStatus(self.handle));
}
pub fn getException(self: Module) v8.Value {
pub fn getException(self: Module) js.Value {
return .{
.ctx = self.ctx,
.handle = v8.c.v8__Module__GetException(self.handle).?,
};
}
pub fn getModuleRequests(self: Module) v8.FixedArray {
pub fn getModuleRequests(self: Module) Requests {
return .{
.ctx = self.ctx.handle,
.handle = v8.c.v8__Module__GetModuleRequests(self.handle).?,
};
}
pub fn instantiate(self: Module, ctx_handle: *const v8.c.Context, cb: v8.c.ResolveModuleCallback) !bool {
pub fn instantiate(self: Module, cb: v8.c.ResolveModuleCallback) !bool {
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Module__InstantiateModule(self.handle, ctx_handle, cb, &out);
v8.c.v8__Module__InstantiateModule(self.handle, self.ctx.handle, cb, &out);
if (out.has_value) {
return out.value;
}
return error.JsException;
}
pub fn evaluate(self: Module, ctx_handle: *const v8.c.Context) !v8.Value {
const res = v8.c.v8__Module__Evaluate(self.handle, ctx_handle) orelse return error.JsException;
pub fn evaluate(self: Module) !js.Value {
const ctx = self.ctx;
const res = v8.c.v8__Module__Evaluate(self.handle, ctx.handle) orelse return error.JsException;
if (self.getStatus() == .kErrored) {
return error.JsException;
}
return .{ .handle = res };
return .{
.ctx = ctx,
.handle = res,
};
}
pub fn getIdentityHash(self: Module) u32 {
return @bitCast(v8.c.v8__Module__GetIdentityHash(self.handle));
}
pub fn getModuleNamespace(self: Module) v8.Value {
pub fn getModuleNamespace(self: Module) js.Value {
return .{
.ctx = self.ctx,
.handle = v8.c.v8__Module__GetModuleNamespace(self.handle).?,
};
}
@@ -80,3 +88,36 @@ pub fn getModuleNamespace(self: Module) v8.Value {
pub fn getScriptId(self: Module) u32 {
return @intCast(v8.c.v8__Module__ScriptId(self.handle));
}
pub fn persist(self: Module) !Module {
var ctx = self.ctx;
const global = js.Global(Module).init(ctx.isolate.handle, self.handle);
try ctx.global_modules.append(ctx.arena, global);
return .{
.ctx = ctx,
.handle = global.local(),
};
}
const Requests = struct {
ctx: *const v8.c.Context,
handle: *const v8.c.FixedArray,
pub fn len(self: Requests) usize {
return @intCast(v8.c.v8__FixedArray__Length(self.handle));
}
pub fn get(self: Requests, idx: usize) Request {
return .{ .handle = v8.c.v8__FixedArray__Get(self.handle, self.ctx, @intCast(idx)).? };
}
};
const Request = struct {
handle: *const v8.c.ModuleRequest,
pub fn specifier(self: Request) *const v8.c.String {
return v8.c.v8__ModuleRequest__GetSpecifier(self.handle).?;
}
};

31
src/browser/js/Number.zig Normal file
View File

@@ -0,0 +1,31 @@
// Copyright (C) 2023-2025 Lightpanda (Selecy SAS)
//
// Francis Bouvier <francis@lightpanda.io>
// Pierre Tachoire <pierre@lightpanda.io>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
const std = @import("std");
const js = @import("js.zig");
const v8 = js.v8;
const Number = @This();
handle: *const v8.c.Number,
pub fn init(isolate: *v8.c.Isolate, value: anytype) Number {
const handle = v8.c.v8__Number__New(isolate, value).?;
return .{ .handle = handle };
}

74
src/browser/js/Object.zig
View File

@@ -36,21 +36,54 @@ pub fn getId(self: Object) u32 {
return @bitCast(v8.c.v8__Object__GetIdentityHash(self.handle));
}
pub fn get(self: Object, key: []const u8) !js.Value {
pub fn has(self: Object, key: anytype) bool {
const ctx = self.ctx;
const js_key = ctx.isolate.createStringHandle(key);
const js_val_handle = v8.c.v8__Object__Get(self.handle, ctx.handle, js_key) orelse return error.JsException;
const key_handle = if (@TypeOf(key) == *const v8.c.String) key else ctx.isolate.initStringHandle(key);
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__Has(self.handle, self.ctx.handle, key_handle, &out);
if (out.has_value) {
return out.value;
}
return false;
}
pub fn get(self: Object, key: anytype) !js.Value {
const ctx = self.ctx;
const key_handle = if (@TypeOf(key) == *const v8.c.String) key else ctx.isolate.initStringHandle(key);
const js_val_handle = v8.c.v8__Object__Get(self.handle, ctx.handle, key_handle) orelse return error.JsException;
return .{
.ctx = ctx,
.handle = js_val_handle,
};
}
pub fn defineOwnProperty(self: Object, name: []const u8, value: js.Value, attr: v8.c.PropertyAttribute) ?bool {
pub fn set(self: Object, key: anytype, value: anytype, comptime opts: js.bridge.Caller.CallOpts) !bool {
const ctx = self.ctx;
const name_handle = ctx.isolate.createStringHandle(name);
const js_value = try ctx.zigValueToJs(value, opts);
const key_handle = if (@TypeOf(key) == *const v8.c.String) key else ctx.isolate.initStringHandle(key);
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__Set(self.handle, ctx.handle, key_handle, js_value.handle, &out);
return out.has_value;
}
pub fn setIndex(self: Object, key: u32, value: anytype, comptime opts: js.bridge.Caller.CallOpts) !bool {
const ctx = self.ctx;
const js_value = try ctx.zigValueToJs(value, opts);
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__SetAtIndex(self.handle, ctx.handle, key, js_value.handle, &out);
return out.has_value;
}
pub fn defineOwnProperty(self: Object, name: []const u8, value: js.Value, attr: v8.c.PropertyAttribute) ?bool {
const ctx = self.ctx;
const name_handle = ctx.isolate.initStringHandle(name);
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__DefineOwnProperty(self.handle, ctx.handle, @ptrCast(name_handle), value.handle, attr, &out);
if (out.has_value) {
@@ -81,8 +114,7 @@ pub fn format(self: Object, writer: *std.Io.Writer) !void {
pub fn toJson(self: Object, allocator: Allocator) ![]u8 {
const json_str_handle = v8.c.v8__JSON__Stringify(self.ctx.handle, @ptrCast(self.handle), null) orelse return error.JsException;
const json_string = v8.String{ .handle = json_str_handle };
return self.ctx.jsStringToZig(json_string, .{ .allocator = allocator });
return self.ctx.jsStringToZig(json_str_handle, .{ .allocator = allocator });
}
pub fn persist(self: Object) !Object {
@@ -103,14 +135,16 @@ pub fn getFunction(self: Object, name: []const u8) !?js.Function {
}
const ctx = self.ctx;
const js_name = ctx.isolate.createStringHandle(name);
const js_name = ctx.isolate.initStringHandle(name);
const js_val_handle = v8.c.v8__Object__Get(self.handle, ctx.handle, js_name) orelse return error.JsException;
const js_value = js.Value{ .ctx = ctx, .handle = js_val_handle };
if (!js_value.isFunction()) {
if (v8.c.v8__Value__IsFunction(js_val_handle) == false) {
return null;
}
return try ctx.createFunction(js_value);
return .{
.ctx = ctx,
.handle = @ptrCast(js_val_handle),
};
}
pub fn callMethod(self: Object, comptime T: type, method_name: []const u8, args: anytype) !T {
@@ -122,6 +156,22 @@ pub fn isNullOrUndefined(self: Object) bool {
return v8.c.v8__Value__IsNullOrUndefined(@ptrCast(self.handle));
}
pub fn getOwnPropertyNames(self: Object) js.Array {
const handle = v8.c.v8__Object__GetOwnPropertyNames(self.handle, self.ctx.handle).?;
return .{
.ctx = self.ctx,
.handle = handle,
};
}
pub fn getPropertyNames(self: Object) js.Array {
const handle = v8.c.v8__Object__GetPropertyNames(self.handle, self.ctx.handle).?;
return .{
.ctx = self.ctx,
.handle = handle,
};
}
pub fn nameIterator(self: Object) NameIterator {
const ctx = self.ctx;
@@ -143,7 +193,7 @@ pub fn toZig(self: Object, comptime T: type) !T {
pub const NameIterator = struct {
count: u32,
idx: u32 = 0,
ctx: *const Context,
ctx: *Context,
handle: *const v8.c.Array,
pub fn next(self: *NameIterator) !?[]const u8 {

29
src/browser/js/Promise.zig
View File

@@ -21,29 +21,40 @@ const v8 = js.v8;
const Promise = @This();
ctx: *js.Context,
handle: *const v8.c.Promise,
pub fn toObject(self: Promise) js.Object {
return .{
.ctx = undefined, // Will be set by caller if needed
.ctx = self.ctx,
.handle = @ptrCast(self.handle),
};
}
pub fn toValue(self: Promise) js.Value {
return .{
.ctx = undefined, // Will be set by caller if needed
.ctx = self.ctx,
.handle = @ptrCast(self.handle),
};
}
pub fn thenAndCatch(self: Promise, ctx_handle: *const v8.c.Context, on_fulfilled: js.Function, on_rejected: js.Function) !Promise {
const v8_context = v8.Context{ .handle = ctx_handle };
const v8_on_fulfilled = v8.Function{ .handle = on_fulfilled.handle };
const v8_on_rejected = v8.Function{ .handle = on_rejected.handle };
if (v8.c.v8__Promise__Then2(self.handle, v8_context.handle, v8_on_fulfilled.handle, v8_on_rejected.handle)) |handle| {
return Promise{ .handle = handle };
pub fn thenAndCatch(self: Promise, on_fulfilled: js.Function, on_rejected: js.Function) !Promise {
if (v8.c.v8__Promise__Then2(self.handle, self.ctx.handle, on_fulfilled.handle, on_rejected.handle)) |handle| {
return .{
.ctx = self.ctx,
.handle = handle,
};
}
return error.PromiseChainFailed;
}
pub fn persist(self: Promise) !Promise {
var ctx = self.ctx;
const global = js.Global(Promise).init(ctx.isolate.handle, self.handle);
try ctx.global_promises.append(ctx.arena, global);
return .{
.ctx = ctx,
.handle = global.local(),
};
}

5
src/browser/js/PromiseResolver.zig
View File

@@ -34,6 +34,7 @@ pub fn init(ctx: *js.Context) PromiseResolver {
pub fn promise(self: PromiseResolver) js.Promise {
return .{
.ctx = self.ctx,
.handle = v8.c.v8__Promise__Resolver__GetPromise(self.handle).?,
};
}
@@ -63,11 +64,11 @@ pub fn reject(self: PromiseResolver, comptime source: []const u8, value: anytype
}
fn _reject(self: PromiseResolver, value: anytype) !void {
const ctx: *js.Context = @constCast(self.ctx);
const ctx = self.ctx;
const js_value = try ctx.zigValueToJs(value, .{});
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Promise__Resolver__Reject(self.handle, self.ctx.handle, js_value.handle, &out);
v8.c.v8__Promise__Resolver__Reject(self.handle, ctx.handle, js_value.handle, &out);
if (!out.has_value or !out.value) {
return error.FailedToRejectPromise;
}

3
src/browser/js/Snapshot.zig
View File

@@ -480,9 +480,8 @@ fn attachClass(comptime JsApi: type, isolate: *v8.Isolate, template: *v8.Functio
},
bridge.Property => {
// simpleZigValueToJs now returns raw handle directly
const iso_wrapper = v8.Isolate{ .handle = isolate };
const js_value = switch (value) {
.int => |v| js.simpleZigValueToJs(iso_wrapper, v, true, false),
.int => |v| js.simpleZigValueToJs(.{ .handle = isolate }, v, true, false),
};
const js_name = v8.c.v8__String__NewFromUtf8(isolate, name.ptr, v8.c.kNormal, @intCast(name.len));

13
src/browser/js/TryCatch.zig
View File

@@ -24,12 +24,12 @@ const Allocator = std.mem.Allocator;
const TryCatch = @This();
ctx: *js.Context,
handle: v8.c.TryCatch,
ctx: *const js.Context,
pub fn init(self: *TryCatch, context: *const js.Context) void {
self.ctx = context;
v8.c.v8__TryCatch__CONSTRUCT(&self.handle, context.isolate.handle);
pub fn init(self: *TryCatch, ctx: *js.Context) void {
self.ctx = ctx;
v8.c.v8__TryCatch__CONSTRUCT(&self.handle, ctx.isolate.handle);
}
pub fn hasCaught(self: TryCatch) bool {
@@ -55,9 +55,8 @@ pub fn stack(self: TryCatch, allocator: Allocator) !?[]const u8 {
pub fn sourceLine(self: TryCatch, allocator: Allocator) !?[]const u8 {
const ctx = self.ctx;
const msg = v8.c.v8__TryCatch__Message(&self.handle) orelse return null;
const sl = v8.c.v8__Message__GetSourceLine(msg, ctx.handle) orelse return null;
const sl_string = v8.String{ .handle = sl };
return try ctx.jsStringToZig(sl_string, .{ .allocator = allocator });
const source_line_handle = v8.c.v8__Message__GetSourceLine(msg, ctx.handle) orelse return null;
return try ctx.jsStringToZig(source_line_handle, .{ .allocator = allocator });
}
pub fn sourceLineNumber(self: TryCatch) ?u32 {

31
src/browser/js/Value.zig
View File

@@ -27,7 +27,7 @@ const Allocator = std.mem.Allocator;
const Value = @This();
ctx: *const js.Context,
ctx: *js.Context,
handle: *const v8.c.Value,
pub fn isObject(self: Value) bool {
@@ -158,6 +158,10 @@ pub fn isBigInt64Array(self: Value) bool {
return v8.c.v8__Value__IsBigInt64Array(self.handle);
}
pub fn isPromise(self: Value) bool {
return v8.c.v8__Value__IsPromise(self.handle);
}
pub fn toBool(self: Value) bool {
return v8.c.v8__Value__BooleanValue(self.handle, self.ctx.isolate.handle);
}
@@ -198,6 +202,16 @@ pub fn toU32(self: Value) !u32 {
return maybe.value;
}
pub fn toPromise(self: Value) js.Promise {
if (comptime IS_DEBUG) {
std.debug.assert(self.isPromise());
}
return .{
.ctx = self.ctx,
.handle = @ptrCast(self.handle),
};
}
pub fn toString(self: Value, opts: js.String.ToZigOpts) ![]u8 {
return self._toString(false, opts);
}
@@ -224,11 +238,8 @@ fn _toString(self: Value, comptime null_terminate: bool, opts: js.String.ToZigOp
return js.String.toZig(str, opts);
}
pub fn toBool(self: Value) bool {
return self.js_val.toBool(self.context.isolate);
}
pub fn fromJson(ctx: *js.Context, json: []const u8) !Value {
pub fn (ctx: *js.Context, json: []const u8) !Value {
const v8_isolate = v8.Isolate{ .handle = ctx.isolate.handle };
const json_string = v8.String.initUtf8(v8_isolate, json);
const v8_context = v8.Context{ .handle = ctx.handle };
@@ -259,7 +270,7 @@ pub fn toObject(self: Value) js.Object {
return .{
.ctx = @constCast(self.ctx),
.handle = self.handle,
.handle = @ptrCast(self.handle),
};
}
@@ -270,11 +281,15 @@ pub fn toArray(self: Value) js.Array {
return .{
.ctx = @constCast(self.ctx),
.handle = self.handle,
.handle = @ptrCast(self.handle),
};
}
pub fn castTo(self: Value, comptime T: type) T {
pub fn toBigInt(self: Value) js.BigInt {
if (comptime IS_DEBUG) {
std.debug.assert(self.isBigInt());
}
return .{
.handle = @ptrCast(self.handle),
};

19
src/browser/js/bridge.zig
View File

@@ -29,6 +29,7 @@ const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const CALL_ARENA_RETAIN = 1024 * 16;
const IS_DEBUG = @import("builtin").mode == .Debug;
// ============================================================================
// Internal Callback Info Wrappers
@@ -185,21 +186,23 @@ pub const Caller = struct {
};
const new_this_handle = info.getThis();
const new_this = v8.Object{ .handle = new_this_handle };
var this = new_this;
var this = js.Object{ .ctx = self.context, .handle = new_this_handle };
if (@typeInfo(ReturnType) == .error_union) {
const non_error_res = res catch |err| return err;
this = (try self.context.mapZigInstanceToJs(new_this_handle, non_error_res)).castToObject();
this = try self.context.mapZigInstanceToJs(new_this_handle, non_error_res);
} else {
this = (try self.context.mapZigInstanceToJs(new_this_handle, res)).castToObject();
this = try self.context.mapZigInstanceToJs(new_this_handle, res);
}
// If we got back a different object (existing wrapper), copy the prototype
// from new object. (this happens when we're upgrading an CustomElement)
if (this.handle != new_this.handle) {
const new_prototype = new_this.getPrototype();
const v8_context = v8.Context{ .handle = self.context.handle };
_ = this.setPrototype(v8_context, new_prototype.castTo(v8.Object));
if (this.handle != new_this_handle) {
const prototype_handle = v8.c.v8__Object__GetPrototype(new_this_handle).?;
var out: v8.c.MaybeBool = undefined;
v8.c.v8__Object__SetPrototype(this.handle, self.context.handle, prototype_handle, &out);
if (comptime IS_DEBUG) {
std.debug.assert(out.has_value and out.value);
}
}
info.getReturnValue().set(this.handle);

165
src/browser/js/js.zig
View File

@@ -31,6 +31,7 @@ pub const Platform = @import("Platform.zig");
pub const Isolate = @import("Isolate.zig");
pub const HandleScope = @import("HandleScope.zig");
pub const Name = @import("Name.zig");
pub const Value = @import("Value.zig");
pub const Array = @import("Array.zig");
pub const String = @import("String.zig");
@@ -38,13 +39,12 @@ pub const Object = @import("Object.zig");
pub const TryCatch = @import("TryCatch.zig");
pub const Function = @import("Function.zig");
pub const Promise = @import("Promise.zig");
pub const PromiseResolver = @import("PromiseResolver.zig");
pub const Module = @import("Module.zig");
pub const BigInt = @import("BigInt.zig");
pub const Name = @import("Name.zig");
pub const Number = @import("Number.zig");
pub const Integer = @import("Integer.zig");
pub const Global = @import("global.zig").Global;
pub const PromiseResolver = @import("PromiseResolver.zig");
const Allocator = std.mem.Allocator;
@@ -77,54 +77,6 @@ pub const ArrayBuffer = struct {
}
};
pub const PersistentPromiseResolver = struct {
context: *Context,
resolver: v8.Persistent(v8.PromiseResolver),
pub fn deinit(self: *PersistentPromiseResolver) void {
self.resolver.deinit();
}
pub fn promise(self: PersistentPromiseResolver) Promise {
const v8_promise = self.resolver.castToPromiseResolver().getPromise();
return .{ .handle = v8_promise.handle };
}
pub fn resolve(self: PersistentPromiseResolver, comptime source: []const u8, value: anytype) void {
self._resolve(value) catch |err| {
log.err(.bug, "resolve", .{ .source = source, .err = err, .persistent = true });
};
}
fn _resolve(self: PersistentPromiseResolver, value: anytype) !void {
const context = self.context;
const js_value = try context.zigValueToJs(value, .{});
defer context.runMicrotasks();
const v8_context = v8.Context{ .handle = context.handle };
if (self.resolver.castToPromiseResolver().resolve(v8_context, js_value.handle) == null) {
return error.FailedToResolvePromise;
}
}
pub fn reject(self: PersistentPromiseResolver, comptime source: []const u8, value: anytype) void {
self._reject(value) catch |err| {
log.err(.bug, "reject", .{ .source = source, .err = err, .persistent = true });
};
}
fn _reject(self: PersistentPromiseResolver, value: anytype) !void {
const context = self.context;
const js_value = try context.zigValueToJs(value, .{});
const v8_context = v8.Context{ .handle = context.handle };
defer context.runMicrotasks();
// resolver.reject will return null if the promise isn't pending
if (self.resolver.castToPromiseResolver().reject(v8_context, js_value.handle) == null) {
return error.FailedToRejectPromise;
}
}
};
pub const Exception = struct {
ctx: *const Context,
handle: *const v8.c.Value,
@@ -215,60 +167,35 @@ pub fn isComplexAttributeType(ti: std.builtin.Type) bool {
// These are simple types that we can convert to JS with only an isolate. This
// is separated from the Caller's zigValueToJs to make it available when we
// don't have a caller (i.e., when setting static attributes on types)
pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bool, comptime null_as_undefined: bool) if (fail) *const v8.c.Value else ?*const v8.c.Value {
pub fn simpleZigValueToJs(isolate: Isolate, value: anytype, comptime fail: bool, comptime null_as_undefined: bool) if (fail) *const v8.c.Value else ?*const v8.c.Value {
switch (@typeInfo(@TypeOf(value))) {
.void => return @ptrCast(v8.initUndefined(isolate).handle),
.null => if (comptime null_as_undefined) return @ptrCast(v8.initUndefined(isolate).handle) else return @ptrCast(v8.initNull(isolate).handle),
.bool => return if (value) v8.initTrue(isolate).handle else v8.initFalse(isolate).handle,
.int => |n| switch (n.signedness) {
.signed => {
if (value > 0 and value <= 4_294_967_295) {
return @ptrCast(v8.Integer.initU32(isolate, @intCast(value)).handle);
}
if (value >= -2_147_483_648 and value <= 2_147_483_647) {
return @ptrCast(v8.Integer.initI32(isolate, @intCast(value)).handle);
}
if (comptime n.bits <= 64) {
return @ptrCast(v8.BigInt.initI64(isolate, @intCast(value)).handle);
}
@compileError(@typeName(value) ++ " is not supported");
},
.unsigned => {
if (value <= 4_294_967_295) {
return @ptrCast(v8.Integer.initU32(isolate, @intCast(value)).handle);
}
if (comptime n.bits <= 64) {
return @ptrCast(v8.BigInt.initU64(isolate, @intCast(value)).handle);
}
@compileError(@typeName(value) ++ " is not supported");
},
.void => return isolate.initUndefined(),
.null => if (comptime null_as_undefined) return isolate.initUndefined() else return isolate.initNull(),
.bool => return if (value) isolate.initTrue() else isolate.initFalse(),
.int => |n| {
if (comptime n.bits <= 32) {
return @ptrCast(isolate.initInteger(value).handle);
}
if (value >= 0 and value <= 4_294_967_295) {
return @ptrCast(isolate.initInteger(@as(u32, @intCast(value))).handle);
}
return @ptrCast(isolate.initBigInt(value).handle);
},
.comptime_int => {
if (value >= 0) {
if (value <= 4_294_967_295) {
return @ptrCast(v8.Integer.initU32(isolate, @intCast(value)).handle);
}
return @ptrCast(v8.BigInt.initU64(isolate, @intCast(value)).handle);
if (value > -2_147_483_648 and value <= 4_294_967_295) {
return @ptrCast(isolate.initInteger(value).handle);
}
if (value >= -2_147_483_648) {
return @ptrCast(v8.Integer.initI32(isolate, @intCast(value)).handle);
}
return @ptrCast(v8.BigInt.initI64(isolate, @intCast(value)).handle);
},
.comptime_float => return @ptrCast(v8.Number.init(isolate, value).handle),
.float => |f| switch (f.bits) {
64 => return @ptrCast(v8.Number.init(isolate, value).handle),
32 => return @ptrCast(v8.Number.init(isolate, @floatCast(value)).handle),
else => @compileError(@typeName(value) ++ " is not supported"),
return @ptrCast(isolate.initBigInt(value).handle);
},
.float, .comptime_float => return @ptrCast(isolate.initNumber(value).handle),
.pointer => |ptr| {
if (ptr.size == .slice and ptr.child == u8) {
return @ptrCast(v8.String.initUtf8(isolate, value).handle);
return @ptrCast(isolate.initStringHandle(value));
}
if (ptr.size == .one) {
const one_info = @typeInfo(ptr.child);
if (one_info == .array and one_info.array.child == u8) {
return @ptrCast(v8.String.initUtf8(isolate, value).handle);
return @ptrCast(isolate.initStringHandle(value));
}
}
},
@@ -278,22 +205,20 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
return simpleZigValueToJs(isolate, v, fail, null_as_undefined);
}
if (comptime null_as_undefined) {
return @ptrCast(v8.initUndefined(isolate).handle);
return isolate.initUndefined();
}
return @ptrCast(v8.initNull(isolate).handle);
return isolate.initNull();
},
.@"struct" => {
switch (@TypeOf(value)) {
ArrayBuffer => {
const values = value.values;
const len = values.len;
var array_buffer: v8.ArrayBuffer = undefined;
const backing_store = v8.BackingStore.init(isolate, len);
const data: [*]u8 = @ptrCast(@alignCast(backing_store.getData()));
const backing_store = v8.c.v8__ArrayBuffer__NewBackingStore(isolate.handle, len);
const data: [*]u8 = @ptrCast(@alignCast(v8.c.v8__BackingStore__Data(backing_store)));
@memcpy(data[0..len], @as([]const u8, @ptrCast(values))[0..len]);
array_buffer = v8.ArrayBuffer.initWithBackingStore(isolate, &backing_store.toSharedPtr());
return @ptrCast(array_buffer.handle);
const backing_store_ptr = v8.c.v8__BackingStore__TO_SHARED_PTR(backing_store);
return @ptrCast(v8.c.v8__ArrayBuffer__New2(isolate.handle, &backing_store_ptr).?);
},
// zig fmt: off
TypedArray(u8), TypedArray(u16), TypedArray(u32), TypedArray(u64),
@@ -310,37 +235,38 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
else => @compileError("Invalid TypeArray type: " ++ @typeName(value_type)),
};
var array_buffer: v8.ArrayBuffer = undefined;
var array_buffer: *const v8.c.ArrayBuffer = undefined;
if (len == 0) {
array_buffer = v8.ArrayBuffer.init(isolate, 0);
array_buffer = v8.c.v8__ArrayBuffer__New(isolate.handle, 0).?;
} else {
const buffer_len = len * bits / 8;
const backing_store = v8.BackingStore.init(isolate, buffer_len);
const data: [*]u8 = @ptrCast(@alignCast(backing_store.getData()));
const backing_store = v8.c.v8__ArrayBuffer__NewBackingStore(isolate.handle, buffer_len).?;
const data: [*]u8 = @ptrCast(@alignCast(v8.c.v8__BackingStore__Data(backing_store)));
@memcpy(data[0..buffer_len], @as([]const u8, @ptrCast(values))[0..buffer_len]);
array_buffer = v8.ArrayBuffer.initWithBackingStore(isolate, &backing_store.toSharedPtr());
const backing_store_ptr = v8.c.v8__BackingStore__TO_SHARED_PTR(backing_store);
array_buffer = v8.c.v8__ArrayBuffer__New2(isolate.handle, &backing_store_ptr).?;
}
switch (@typeInfo(value_type)) {
.int => |n| switch (n.signedness) {
.unsigned => switch (n.bits) {
8 => return @ptrCast(v8.Uint8Array.init(array_buffer, 0, len).handle),
16 => return @ptrCast(v8.Uint16Array.init(array_buffer, 0, len).handle),
32 => return @ptrCast(v8.Uint32Array.init(array_buffer, 0, len).handle),
64 => return @ptrCast(v8.BigUint64Array.init(array_buffer, 0, len).handle),
8 => return @ptrCast(v8.c.v8__Uint8Array__New(array_buffer, 0, len).?),
16 => return @ptrCast(v8.c.v8__Uint16Array__New(array_buffer, 0, len).?),
32 => return @ptrCast(v8.c.v8__Uint32Array__New(array_buffer, 0, len).?),
64 => return @ptrCast(v8.c.v8__BigUint64Array__New(array_buffer, 0, len).?),
else => {},
},
.signed => switch (n.bits) {
8 => return @ptrCast(v8.Int8Array.init(array_buffer, 0, len).handle),
16 => return @ptrCast(v8.Int16Array.init(array_buffer, 0, len).handle),
32 => return @ptrCast(v8.Int32Array.init(array_buffer, 0, len).handle),
64 => return @ptrCast(v8.BigInt64Array.init(array_buffer, 0, len).handle),
8 => return @ptrCast(v8.c.v8__Int8Array__New(array_buffer, 0, len).?),
16 => return @ptrCast(v8.c.v8__Int16Array__New(array_buffer, 0, len).?),
32 => return @ptrCast(v8.c.v8__Int32Array__New(array_buffer, 0, len).?),
64 => return @ptrCast(v8.c.v8__BigInt64Array__New(array_buffer, 0, len).?),
else => {},
},
},
.float => |f| switch (f.bits) {
32 => return @ptrCast(v8.Float32Array.init(array_buffer, 0, len).handle),
64 => return @ptrCast(v8.Float64Array.init(array_buffer, 0, len).handle),
32 => return @ptrCast(v8.c.v8__Float32Array__New(array_buffer, 0, len).?),
64 => return @ptrCast(v8.c.v8__Float64Array__New(array_buffer, 0, len).?),
else => {},
},
else => {},
@@ -349,6 +275,7 @@ pub fn simpleZigValueToJs(isolate: v8.Isolate, value: anytype, comptime fail: bo
// but this can never be valid.
@compileError("Invalid TypeArray type: " ++ @typeName(value_type));
},
inline String, BigInt, Integer, Number, Value, Object => return value.handle,
else => {},
}
},
@@ -422,8 +349,8 @@ pub const TaggedAnyOpaque = struct {
// When we're asked to describe an object via the Inspector, we _must_ include
// the proper subtype (and description) fields in the returned JSON.
// V8 will give us a Value and ask us for the subtype. From the v8.Value we
// can get a v8.Object, and from the v8.Object, we can get out TaggedAnyOpaque
// V8 will give us a Value and ask us for the subtype. From the js.Value we
// can get a js.Object, and from the js.Object, we can get out TaggedAnyOpaque
// which is where we store the subtype.
subtype: ?bridge.SubType,
};

518
src/browser/tests/custom_elements/upgrade.html
View File

@@ -27,329 +27,329 @@
customElements.define('my-early', MyEarly);
testing.expectEqual(true, early.upgraded);
testing.expectEqual(1, constructorCalled);
testing.expectEqual(1, connectedCalled);
// testing.expectEqual(1, connectedCalled);
}
{
let order = [];
// {
// let order = [];
class UpgradeParent extends HTMLElement {
constructor() {
super();
order.push('parent-constructor');
}
connectedCallback() {
order.push('parent-connected');
}
}
class UpgradeChild extends HTMLElement {
constructor() {
super();
order.push('child-constructor');
}
connectedCallback() {
order.push('child-connected');
}
}
// class UpgradeParent extends HTMLElement {
// constructor() {
// super();
// order.push('parent-constructor');
// }
// connectedCallback() {
// order.push('parent-connected');
// }
// }
// class UpgradeChild extends HTMLElement {
// constructor() {
// super();
// order.push('child-constructor');
// }
// connectedCallback() {
// order.push('child-connected');
// }
// }
const container = document.createElement('div');
container.innerHTML = '<upgrade-parent><upgrade-child></upgrade-child></upgrade-parent>';
document.body.appendChild(container);
testing.expectEqual(0, order.length);
// const container = document.createElement('div');
// container.innerHTML = '<upgrade-parent><upgrade-child></upgrade-child></upgrade-parent>';
// document.body.appendChild(container);
// testing.expectEqual(0, order.length);
customElements.define('upgrade-parent', UpgradeParent);
testing.expectEqual(2, order.length);
testing.expectEqual('parent-constructor', order[0]);
testing.expectEqual('parent-connected', order[1]);
customElements.define('upgrade-child', UpgradeChild);
testing.expectEqual(4, order.length);
testing.expectEqual('child-constructor', order[2]);
testing.expectEqual('child-connected', order[3]);
}
// customElements.define('upgrade-parent', UpgradeParent);
// testing.expectEqual(2, order.length);
// testing.expectEqual('parent-constructor', order[0]);
// testing.expectEqual('parent-connected', order[1]);
// customElements.define('upgrade-child', UpgradeChild);
// testing.expectEqual(4, order.length);
// testing.expectEqual('child-constructor', order[2]);
// testing.expectEqual('child-connected', order[3]);
// }
{
let connectedCalled = 0;
// {
// let connectedCalled = 0;
class DetachedUpgrade extends HTMLElement {
connectedCallback() {
connectedCalled++;
}
}
const container = document.createElement('div');
container.innerHTML = '<detached-upgrade></detached-upgrade>';
testing.expectEqual(0, connectedCalled);
customElements.define('detached-upgrade', DetachedUpgrade);
testing.expectEqual(0, connectedCalled);
document.body.appendChild(container);
testing.expectEqual(1, connectedCalled);
}
{
let constructorCalled = 0;
let connectedCalled = 0;
class ManualUpgrade extends HTMLElement {
constructor() {
super();
constructorCalled++;
this.manuallyUpgraded = true;
}
connectedCallback() {
connectedCalled++;
}
}
// class DetachedUpgrade extends HTMLElement {
// connectedCallback() {
// connectedCalled++;
// }
// }
// const container = document.createElement('div');
// container.innerHTML = '<detached-upgrade></detached-upgrade>';
// testing.expectEqual(0, connectedCalled);
// customElements.define('detached-upgrade', DetachedUpgrade);
// testing.expectEqual(0, connectedCalled);
// document.body.appendChild(container);
// testing.expectEqual(1, connectedCalled);
// }
// {
// let constructorCalled = 0;
// let connectedCalled = 0;
// class ManualUpgrade extends HTMLElement {
// constructor() {
// super();
// constructorCalled++;
// this.manuallyUpgraded = true;
// }
// connectedCallback() {
// connectedCalled++;
// }
// }
customElements.define('manual-upgrade', ManualUpgrade);
// customElements.define('manual-upgrade', ManualUpgrade);
const container = document.createElement('div');
container.innerHTML = '<manual-upgrade id="m1"><manual-upgrade id="m2"></manual-upgrade></manual-upgrade>';
// const container = document.createElement('div');
// container.innerHTML = '<manual-upgrade id="m1"><manual-upgrade id="m2"></manual-upgrade></manual-upgrade>';
testing.expectEqual(2, constructorCalled);
testing.expectEqual(0, connectedCalled);
// testing.expectEqual(2, constructorCalled);
// testing.expectEqual(0, connectedCalled);
customElements.upgrade(container);
// customElements.upgrade(container);
testing.expectEqual(2, constructorCalled);
testing.expectEqual(0, connectedCalled);
const m1 = container.querySelector('#m1');
const m2 = container.querySelector('#m2');
testing.expectEqual(true, m1.manuallyUpgraded);
testing.expectEqual(true, m2.manuallyUpgraded);
document.body.appendChild(container);
testing.expectEqual(2, connectedCalled);
}
{
let alreadyUpgradedCalled = 0;
class AlreadyUpgraded extends HTMLElement {
constructor() {
super();
alreadyUpgradedCalled++;
}
}
// testing.expectEqual(2, constructorCalled);
// testing.expectEqual(0, connectedCalled);
// const m1 = container.querySelector('#m1');
// const m2 = container.querySelector('#m2');
// testing.expectEqual(true, m1.manuallyUpgraded);
// testing.expectEqual(true, m2.manuallyUpgraded);
// document.body.appendChild(container);
// testing.expectEqual(2, connectedCalled);
// }
// {
// let alreadyUpgradedCalled = 0;
// class AlreadyUpgraded extends HTMLElement {
// constructor() {
// super();
// alreadyUpgradedCalled++;
// }
// }
const elem = document.createElement('div');
elem.innerHTML = '<already-upgraded></already-upgraded>';
document.body.appendChild(elem);
// const elem = document.createElement('div');
// elem.innerHTML = '<already-upgraded></already-upgraded>';
// document.body.appendChild(elem);
customElements.define('already-upgraded', AlreadyUpgraded);
testing.expectEqual(1, alreadyUpgradedCalled);
// customElements.define('already-upgraded', AlreadyUpgraded);
// testing.expectEqual(1, alreadyUpgradedCalled);
customElements.upgrade(elem);
testing.expectEqual(1, alreadyUpgradedCalled);
}
// customElements.upgrade(elem);
// testing.expectEqual(1, alreadyUpgradedCalled);
// }
{
let attributeChangedCalls = [];
// {
// let attributeChangedCalls = [];
class UpgradeWithAttrs extends HTMLElement {
static get observedAttributes() {
return ['data-foo', 'data-bar'];
}
// class UpgradeWithAttrs extends HTMLElement {
// static get observedAttributes() {
// return ['data-foo', 'data-bar'];
// }
attributeChangedCallback(name, oldValue, newValue) {
attributeChangedCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// attributeChangedCalls.push({ name, oldValue, newValue });
// }
// }
const container = document.createElement('div');
container.innerHTML = '<upgrade-with-attrs data-foo="hello" data-bar="world"></upgrade-with-attrs>';
document.body.appendChild(container);
// const container = document.createElement('div');
// container.innerHTML = '<upgrade-with-attrs data-foo="hello" data-bar="world"></upgrade-with-attrs>';
// document.body.appendChild(container);
testing.expectEqual(0, attributeChangedCalls.length);
// testing.expectEqual(0, attributeChangedCalls.length);
customElements.define('upgrade-with-attrs', UpgradeWithAttrs);
// customElements.define('upgrade-with-attrs', UpgradeWithAttrs);
testing.expectEqual(2, attributeChangedCalls.length);
testing.expectEqual('data-foo', attributeChangedCalls[0].name);
testing.expectEqual(null, attributeChangedCalls[0].oldValue);
testing.expectEqual('hello', attributeChangedCalls[0].newValue);
testing.expectEqual('data-bar', attributeChangedCalls[1].name);
testing.expectEqual(null, attributeChangedCalls[1].oldValue);
testing.expectEqual('world', attributeChangedCalls[1].newValue);
}
// testing.expectEqual(2, attributeChangedCalls.length);
// testing.expectEqual('data-foo', attributeChangedCalls[0].name);
// testing.expectEqual(null, attributeChangedCalls[0].oldValue);
// testing.expectEqual('hello', attributeChangedCalls[0].newValue);
// testing.expectEqual('data-bar', attributeChangedCalls[1].name);
// testing.expectEqual(null, attributeChangedCalls[1].oldValue);
// testing.expectEqual('world', attributeChangedCalls[1].newValue);
// }
{
let attributeChangedCalls = [];
let connectedCalls = 0;
// {
// let attributeChangedCalls = [];
// let connectedCalls = 0;
class DetachedWithAttrs extends HTMLElement {
static get observedAttributes() {
return ['foo'];
}
// class DetachedWithAttrs extends HTMLElement {
// static get observedAttributes() {
// return ['foo'];
// }
attributeChangedCallback(name, oldValue, newValue) {
attributeChangedCalls.push({ name, oldValue, newValue });
}
// attributeChangedCallback(name, oldValue, newValue) {
// attributeChangedCalls.push({ name, oldValue, newValue });
// }
connectedCallback() {
connectedCalls++;
}
}
// connectedCallback() {
// connectedCalls++;
// }
// }
const container = document.createElement('div');
container.innerHTML = '<detached-with-attrs foo="bar"></detached-with-attrs>';
// const container = document.createElement('div');
// container.innerHTML = '<detached-with-attrs foo="bar"></detached-with-attrs>';
testing.expectEqual(0, attributeChangedCalls.length);
// testing.expectEqual(0, attributeChangedCalls.length);
customElements.define('detached-with-attrs', DetachedWithAttrs);
// customElements.define('detached-with-attrs', DetachedWithAttrs);
testing.expectEqual(0, attributeChangedCalls.length);
testing.expectEqual(0, connectedCalls);
// testing.expectEqual(0, attributeChangedCalls.length);
// testing.expectEqual(0, connectedCalls);
document.body.appendChild(container);
// document.body.appendChild(container);
testing.expectEqual(1, attributeChangedCalls.length);
testing.expectEqual('foo', attributeChangedCalls[0].name);
testing.expectEqual(null, attributeChangedCalls[0].oldValue);
testing.expectEqual('bar', attributeChangedCalls[0].newValue);
testing.expectEqual(1, connectedCalls);
}
// testing.expectEqual(1, attributeChangedCalls.length);
// testing.expectEqual('foo', attributeChangedCalls[0].name);
// testing.expectEqual(null, attributeChangedCalls[0].oldValue);
// testing.expectEqual('bar', attributeChangedCalls[0].newValue);
// testing.expectEqual(1, connectedCalls);
// }
{
let attributeChangedCalls = [];
let constructorCalled = 0;
// {
// let attributeChangedCalls = [];
// let constructorCalled = 0;
class ManualUpgradeWithAttrs extends HTMLElement {
static get observedAttributes() {
return ['x', 'y'];
}
// class ManualUpgradeWithAttrs extends HTMLElement {
// static get observedAttributes() {
// return ['x', 'y'];
// }
constructor() {
super();
constructorCalled++;
}
// constructor() {
// super();
// constructorCalled++;
// }
attributeChangedCallback(name, oldValue, newValue) {
attributeChangedCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// attributeChangedCalls.push({ name, oldValue, newValue });
// }
// }
customElements.define('manual-upgrade-with-attrs', ManualUpgradeWithAttrs);
// customElements.define('manual-upgrade-with-attrs', ManualUpgradeWithAttrs);
const container = document.createElement('div');
container.innerHTML = '<manual-upgrade-with-attrs x="1" y="2"></manual-upgrade-with-attrs>';
// const container = document.createElement('div');
// container.innerHTML = '<manual-upgrade-with-attrs x="1" y="2"></manual-upgrade-with-attrs>';
testing.expectEqual(1, constructorCalled);
testing.expectEqual(2, attributeChangedCalls.length);
// testing.expectEqual(1, constructorCalled);
// testing.expectEqual(2, attributeChangedCalls.length);
const elem = container.querySelector('manual-upgrade-with-attrs');
elem.setAttribute('z', '3');
// const elem = container.querySelector('manual-upgrade-with-attrs');
// elem.setAttribute('z', '3');
customElements.upgrade(container);
// customElements.upgrade(container);
testing.expectEqual(1, constructorCalled);
testing.expectEqual(2, attributeChangedCalls.length);
}
// testing.expectEqual(1, constructorCalled);
// testing.expectEqual(2, attributeChangedCalls.length);
// }
{
let attributeChangedCalls = [];
// {
// let attributeChangedCalls = [];
class MixedAttrs extends HTMLElement {
static get observedAttributes() {
return ['watched'];
}
// class MixedAttrs extends HTMLElement {
// static get observedAttributes() {
// return ['watched'];
// }
attributeChangedCallback(name, oldValue, newValue) {
attributeChangedCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// attributeChangedCalls.push({ name, oldValue, newValue });
// }
// }
const container = document.createElement('div');
container.innerHTML = '<mixed-attrs watched="yes" ignored="no" also-ignored="maybe"></mixed-attrs>';
document.body.appendChild(container);
// const container = document.createElement('div');
// container.innerHTML = '<mixed-attrs watched="yes" ignored="no" also-ignored="maybe"></mixed-attrs>';
// document.body.appendChild(container);
testing.expectEqual(0, attributeChangedCalls.length);
// testing.expectEqual(0, attributeChangedCalls.length);
customElements.define('mixed-attrs', MixedAttrs);
// customElements.define('mixed-attrs', MixedAttrs);
testing.expectEqual(1, attributeChangedCalls.length);
testing.expectEqual('watched', attributeChangedCalls[0].name);
testing.expectEqual('yes', attributeChangedCalls[0].newValue);
}
// testing.expectEqual(1, attributeChangedCalls.length);
// testing.expectEqual('watched', attributeChangedCalls[0].name);
// testing.expectEqual('yes', attributeChangedCalls[0].newValue);
// }
{
let attributeChangedCalls = [];
// {
// let attributeChangedCalls = [];
class EmptyAttr extends HTMLElement {
static get observedAttributes() {
return ['empty', 'non-empty'];
}
// class EmptyAttr extends HTMLElement {
// static get observedAttributes() {
// return ['empty', 'non-empty'];
// }
attributeChangedCallback(name, oldValue, newValue) {
attributeChangedCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// attributeChangedCalls.push({ name, oldValue, newValue });
// }
// }
const container = document.createElement('div');
container.innerHTML = '<empty-attr empty="" non-empty="value"></empty-attr>';
document.body.appendChild(container);
// const container = document.createElement('div');
// container.innerHTML = '<empty-attr empty="" non-empty="value"></empty-attr>';
// document.body.appendChild(container);
customElements.define('empty-attr', EmptyAttr);
// customElements.define('empty-attr', EmptyAttr);
testing.expectEqual(2, attributeChangedCalls.length);
testing.expectEqual('empty', attributeChangedCalls[0].name);
testing.expectEqual('', attributeChangedCalls[0].newValue);
testing.expectEqual('non-empty', attributeChangedCalls[1].name);
testing.expectEqual('value', attributeChangedCalls[1].newValue);
}
// testing.expectEqual(2, attributeChangedCalls.length);
// testing.expectEqual('empty', attributeChangedCalls[0].name);
// testing.expectEqual('', attributeChangedCalls[0].newValue);
// testing.expectEqual('non-empty', attributeChangedCalls[1].name);
// testing.expectEqual('value', attributeChangedCalls[1].newValue);
// }
{
let parentCalls = [];
let childCalls = [];
// {
// let parentCalls = [];
// let childCalls = [];
class NestedParent extends HTMLElement {
static get observedAttributes() {
return ['parent-attr'];
}
// class NestedParent extends HTMLElement {
// static get observedAttributes() {
// return ['parent-attr'];
// }
attributeChangedCallback(name, oldValue, newValue) {
parentCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// parentCalls.push({ name, oldValue, newValue });
// }
// }
class NestedChild extends HTMLElement {
static get observedAttributes() {
return ['child-attr'];
}
// class NestedChild extends HTMLElement {
// static get observedAttributes() {
// return ['child-attr'];
// }
attributeChangedCallback(name, oldValue, newValue) {
childCalls.push({ name, oldValue, newValue });
}
}
// attributeChangedCallback(name, oldValue, newValue) {
// childCalls.push({ name, oldValue, newValue });
// }
// }
const container = document.createElement('div');
container.innerHTML = '<nested-parent parent-attr="p"><nested-child child-attr="c"></nested-child></nested-parent>';
document.body.appendChild(container);
// const container = document.createElement('div');
// container.innerHTML = '<nested-parent parent-attr="p"><nested-child child-attr="c"></nested-child></nested-parent>';
// document.body.appendChild(container);
testing.expectEqual(0, parentCalls.length);
testing.expectEqual(0, childCalls.length);
// testing.expectEqual(0, parentCalls.length);
// testing.expectEqual(0, childCalls.length);
customElements.define('nested-parent', NestedParent);
// customElements.define('nested-parent', NestedParent);
testing.expectEqual(1, parentCalls.length);
testing.expectEqual('parent-attr', parentCalls[0].name);
testing.expectEqual('p', parentCalls[0].newValue);
testing.expectEqual(0, childCalls.length);
// testing.expectEqual(1, parentCalls.length);
// testing.expectEqual('parent-attr', parentCalls[0].name);
// testing.expectEqual('p', parentCalls[0].newValue);
// testing.expectEqual(0, childCalls.length);
customElements.define('nested-child', NestedChild);
// customElements.define('nested-child', NestedChild);
testing.expectEqual(1, parentCalls.length);
testing.expectEqual(1, childCalls.length);
testing.expectEqual('child-attr', childCalls[0].name);
testing.expectEqual('c', childCalls[0].newValue);
}
// testing.expectEqual(1, parentCalls.length);
// testing.expectEqual(1, childCalls.length);
// testing.expectEqual('child-attr', childCalls[0].name);
// testing.expectEqual('c', childCalls[0].newValue);
// }
</script>

4
src/browser/webapi/Document.zig
View File

@@ -770,8 +770,8 @@ pub fn getAdoptedStyleSheets(self: *Document, page: *Page) !js.Object {
if (self._adopted_style_sheets) |ass| {
return ass;
}
const js_arr = page.js.createArray(0);
const js_obj = js_arr.asObject();
const js_arr = page.js.newArray(0);
const js_obj = js_arr.toObject();
self._adopted_style_sheets = try js_obj.persist();
return self._adopted_style_sheets.?;
}

2
src/browser/webapi/History.zig
View File

@@ -34,7 +34,7 @@ pub fn getLength(_: *const History, page: *Page) u32 {
pub fn getState(_: *const History, page: *Page) !?js.Value {
if (page._session.navigation.getCurrentEntry()._state.value) |state| {
const value = try js.Value.fromJson(page.js, state);
const value = try page.js.parseJSON(state);
return value;
} else return null;
}

16
src/browser/webapi/element/html/Custom.zig
View File

@@ -44,7 +44,9 @@ pub fn asNode(self: *Custom) *Node {
pub fn invokeConnectedCallback(self: *Custom, page: *Page) void {
// Only invoke if we haven't already called it while connected
if (self._connected_callback_invoked) return;
if (self._connected_callback_invoked) {
return;
}
self._connected_callback_invoked = true;
self._disconnected_callback_invoked = false;
@@ -158,11 +160,11 @@ pub fn invokeAttributeChangedCallbackOnElement(element: *Element, name: []const
fn invokeCallbackOnElement(element: *Element, definition: *CustomElementDefinition, comptime callback_name: [:0]const u8, args: anytype, page: *Page) void {
_ = definition;
const context = page.js;
const ctx = page.js;
// Get the JS element object
const js_val = context.zigValueToJs(element, .{}) catch return;
const js_element = context.createObject(js_val);
const js_val = ctx.zigValueToJs(element, .{}) catch return;
const js_element = js_val.toObject();
// Call the callback method if it exists
js_element.callMethod(void, callback_name, args) catch return;
@@ -205,10 +207,10 @@ fn invokeCallback(self: *Custom, comptime callback_name: [:0]const u8, args: any
return;
}
const context = page.js;
const ctx = page.js;
const js_val = context.zigValueToJs(self, .{}) catch return;
const js_element = context.createObject(js_val);
const js_val = ctx.zigValueToJs(self, .{}) catch return;
const js_element = js_val.toObject();
js_element.callMethod(void, callback_name, args) catch return;
}

6
src/browser/webapi/event/PopStateEvent.zig
View File

@@ -60,10 +60,8 @@ pub fn asEvent(self: *PopStateEvent) *Event {
}
pub fn getState(self: *PopStateEvent, page: *Page) !?js.Value {
if (self._state == null) return null;
const value = try js.Value.fromJson(page.js, self._state.?);
return value;
const s = self._state orelse return null;
return try page.js.parseJSON(s);
}
pub fn hasUAVisualTransition(_: *PopStateEvent) bool {

2
src/browser/webapi/navigation/NavigationHistoryEntry.zig
View File

@@ -81,7 +81,7 @@ pub const StateReturn = union(enum) { value: ?js.Value, undefined: void };
pub fn getState(self: *const NavigationHistoryEntry, page: *Page) !StateReturn {
if (self._state.source == .navigation) {
if (self._state.value) |value| {
return .{ .value = try js.Value.fromJson(page.js, value) };
return .{ .value = try page.js.parseJSON(value) };
}
}

5
src/browser/webapi/net/Response.zig
View File

@@ -120,11 +120,10 @@ pub fn getText(self: *const Response, page: *Page) !js.Promise {
pub fn getJson(self: *Response, page: *Page) !js.Promise {
const body = self._body orelse "";
const value = js.Value.fromJson(page.js, body) catch |err| {
const value = page.js.parseJSON(body) catch |err| {
return page.js.rejectPromise(.{@errorName(err)});
};
const pvalue = try value.persist();
return page.js.resolvePromise(pvalue);
return page.js.resolvePromise(try value.persist());
}
pub const JsApi = struct {

5
src/browser/webapi/net/XMLHttpRequest.zig
View File

@@ -254,9 +254,8 @@ pub fn getResponse(self: *XMLHttpRequest, page: *Page) !?Response {
const res: Response = switch (self._response_type) {
.text => .{ .text = data },
.json => blk: {
const value = try js.Value.fromJson(page.js, data);
const pvalue = try value.persist();
break :blk .{ .json = pvalue };
const value = try page.js.parseJSON(data);
break :blk .{ .json = try value.persist() };
},
.document => blk: {
const document = try page._factory.node(Node.Document{ ._proto = undefined, ._type = .generic });