aboutsummaryrefslogtreecommitdiff
path: root/src/z/Component.zig
blob: f3a1a990e6e4cb528230651c860c48b5c701a13a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
const std = @import("std");
const Element = @import("html.zig").Element;
const Object = @import("Object.zig");

const Self = @This();

name: []const u8,
html: Element,
css: []const u8,
link: type,

fn exportFromHtml(self: *const Self, element: Element) void {
    comptime {
        for (element.attributes) |attr| {
            if (attr.value.len > 0 and attr.value[0] == '@') {
                const func = struct {
                    pub fn func(obj: *self.link) callconv(.c) void {
                        @field(self.link, attr.value[1..])(obj);
                    }
                }.func;

                @export(
                    &func,
                    .{
                        .name = std.fmt.comptimePrint(
                            "export::{s}::{s}",
                            .{ self.name, attr.value[1..] },
                        ),
                    },
                );
            }
        }
    }
}

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;
            obj.init(element);
            return obj;
        }
    }.init;

    @export(
        &init,
        .{
            .name = std.fmt.comptimePrint(
                "export::{s}::init",
                .{ self.name },
            ),
        },
    );

    comptime self.exportFromHtml(self.html);
}

fn linkHtmlRecursive(self: *const Self, element: Element) Element {
    comptime {
        return .{
            .tag = element.tag,
            .attributes = attrs: {
                var attributes: []const Element.Attribute = &.{};

                for (element.attributes) |*attr| {
                    if (attr.value.len > 0 and attr.value[0] == '@') {
                        const attribute: []const Element.Attribute = &.{.{
                            .name = attr.name,
                            .value = std.fmt.comptimePrint(
                                "wasm.exports[\"export::{s}::{s}\"](this[\"@ptr\"])",
                                .{ self.name, attr.value[1..] },
                            ),
                        }};
                        attributes = attributes ++ attribute;
                    }
                }
                break :attrs attributes;
            },
            .content = element.content,
        };
    }
}

pub fn toElement(self: *const Self) Element {
    return .transparent(
        .children(
            &.{
                .native(
                    .template,
                    .{ .id = "@" ++ self.name },
                    .children(&.{
                        .native(.style, .{}, .content(self.css)),
                        self.linkHtmlRecursive(self.html)
                    }),
                ),
                .native(
                    .script,
                    .{},
                    .content(
                        std.fmt.comptimePrint(
                            \\customElements.define("app-{s}", class extends HTMLElement {{
                            \\  constructor() {{
                            \\      super();
                            \\      this.attachShadow({{ mode: 'open' }});
                            \\      const template = document.getElementById("@{s}");
                            \\      const node = document.importNode(template.content, true);
                            \\      this.shadowRoot.appendChild(node);
                            \\      this['@ptr'] = null;
                            \\  }}
                            \\  connectedCallback() {{
                            \\      wasm_ready.then(() => {{
                            \\          const id = ObjectStore.generateFreeId();
                            \\          ObjectStore.registerObject(id, this);
                            \\          this['@ptr'] = wasm.exports['export::{s}::init'](id)
                            \\      }});
                            \\  }}
                            \\}})
                            ,
                            .{self.name, self.name, self.name}
                        ),
                    ),
                ),
            },
        ),
    );
}