diff options
Diffstat (limited to 'src/zilch/Component.zig')
| -rw-r--r-- | src/zilch/Component.zig | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/src/zilch/Component.zig b/src/zilch/Component.zig new file mode 100644 index 0000000..592b464 --- /dev/null +++ b/src/zilch/Component.zig @@ -0,0 +1,225 @@ +const std = @import("std"); +const Fragment = @import("root.zig").html.Fragment; +const Element = @import("root.zig").html.Element; +const Attribute = @import("root.zig").html.Attribute; +const Object = @import("Object.zig"); +const Env = @import("root.zig").Env; +const Function = Env.Function; +const Future = Env.Future; + +const Self = @This(); + +pub const Options = struct { + namespace: []const u8 = "app", + name: []const u8, + html: Fragment, + css: []const u8, + link: type, +}; + +namespace: []const u8, +name: []const u8, +html: Fragment, +css: []const u8, +link: type, +id: u32, + +pub fn build(comptime options: Options) Self { + return .{ + .namespace = options.namespace, + .name = options.name, + .html = options.html, + .css = options.css, + .link = options.link, + .id = std.hash.XxHash32.hash(4654, options.namespace ++ "-" ++ options.name), + }; +} + +fn handlerNeedsEvent(func: anytype) bool { + const T = @TypeOf(func); + return @typeInfo(T).@"fn".params.len == 2; +} + +fn wrapHandler(ret: anytype) void { + const T = @TypeOf(ret); + const ret_info = @typeInfo(T); + + if (ret_info == .error_union) { + ret catch |err| { + std.log.err("error: {}", .{err}); + }; + } +} + +fn exportFromHtml(self: *const Self, element: Element) void { + comptime { + switch (element) { + .tag => |tag| for (tag.attributes) |attr| { + if (attr.value.len > 0 and attr.value[0] == '@') { + const event_handler = @field(self.link, attr.value[1..]); + + const func = + if (handlerNeedsEvent(event_handler)) + struct { + pub fn func(obj: *self.link, event: *Object) callconv(.c) void { + wrapHandler(event_handler(obj, event)); + } + }.func + else + struct { + pub fn func(obj: *self.link) callconv(.c) void { + wrapHandler(event_handler(obj)); + } + }.func; + + @export( + &func, + .{ + .name = std.fmt.comptimePrint( + "export::{s}::{s}", + .{ self.name, attr.value[1..] }, + ), + }, + ); + } + + switch (tag.content) { + .children => |children| for (children) |child| { + self.exportFromHtml(child); + }, + else => {}, + } + }, + else => {}, + } + } +} + +pub fn exportLinks(self: *const Self) void { + const init = struct { + pub fn init(element: *Object) callconv(.c) ?*self.link { + const obj = std.heap.wasm_allocator.create(self.link) catch return null; + if (@hasDecl(self.link, "init")) { + wrapHandler(obj.init(element)); + } + return obj; + } + }.init; + + @export( + &init, + .{ + .name = std.fmt.comptimePrint( + "export::{s}::init", + .{self.name}, + ), + }, + ); + + for (self.html.elements) |element| { + comptime self.exportFromHtml(element); + } +} + +fn linkAttributes(self: *const Self, attributes: []const Attribute) []const Attribute { + var linked: []const Attribute = &.{}; + + for (attributes) |attr| { + if (attr.value.len > 0 and attr.value[0] == '@') { + const event_handler = @field(self.link, attr.value[1..]); + const attribute: Attribute = .{ + .name = attr.name, + .value = std.fmt.comptimePrint( + "wasm_handle_event(this, \"export::{s}::{s}\", event, {})", + .{ self.name, attr.value[1..], handlerNeedsEvent(event_handler) }, + ), + }; + linked = linked ++ .{attribute}; + } else { + linked = linked ++ .{attr}; + } + } + return linked; +} + +fn linkHtmlRecursive(self: *const Self, element: Element) Element { + comptime { + return switch (element) { + .tag => |el| .{ + .tag = .{ + .name = el.name, + .attributes = self.linkAttributes(el.attributes), + .content = switch (el.content) { + .children => |children| ch: { + var elements: []const Element = &.{}; + + for (children) |child| { + const e: []const Element = &.{self.linkHtmlRecursive(child)}; + elements = elements ++ e; + } + + break :ch .{ .children = elements }; + }, + .void => .void, + }, + }, + }, + .string => element, + }; + } +} + +pub fn toElement(self: *const Self) []const Element { + return &.{ + .node( + "template", + .{ .id = "@" ++ self.name }, + [_]Element{ + .node("style", .{}, &.{.text(self.css)}), + } ++ (html: { + var elements: []const Element = &.{}; + + for (self.html.elements) |element| { + elements = elements ++ .{self.linkHtmlRecursive(element)}; + } + + break :html elements; + }), + ), + .node( + "script", + .{}, + &.{.text( + std.fmt.comptimePrint( + @embedFile("component.template.js"), + .{ + self.namespace, + self.name, + self.name, + self.name, + }, + ), + )}, + ), + }; +} + +pub fn new(self: Self, obj: *self.link, env: *Env) Future(*Object) { + return .fromAny(env.call(bindings.new, .{ @as(usize, @intCast(self.id)), @intFromPtr(obj) })); +} + +const bindings = struct { + pub const new: Function = .from( + \\function(name_id, ptr) { + \\ const el = document.createElement(component_registry[name_id]); + \\ el[ZsPtr] = ptr; + \\ const id = ObjectStore.generateFreeId(); + \\ ObjectStore.registerObject(id, el); + \\ return el; + \\} + ); +}; + +pub const functions = [_]Function{ + bindings.new, +}; |