(data (i32.const 0x42) "Hello, Reference Types!
")

let input: &[u8] = ...;
linker
.func_wrap("my_host", "get_input_size", move || -> i32 {
input.len() as i32
})
.unwrap();

linker
.func_wrap(
"my_host",
"get_input",
move |mut caller: Caller<'_, WasiState>, ptr: i32| {
let mem = caller.get_export("memory").unwrap().into_memory().unwrap();
let offset = ptr as u32 as usize;
mem.write(&mut caller, offset, input).unwrap();
},
)
.unwrap();

-- component page:

-- page-desktop:
if: { ftd.device == "desktop" }

-- page-mobile:
if: { ftd.device == "mobile" }

-- end: page

-- boolean f: foo()

-- boolean foo:

bar()

struct Window {
// private stuff
}

enum Element {
FlexContainer(FlexContainer),
Text(Text),
Image(Image),
Code(Code),
TextInput(TextInput),
}

let root = construct_root();
let title = "hello";

let win = fastn_surface::web::create_root_window(title);
win.run();

new_key_type! { struct NodeKey; }

enum NodeKind {
FlexContainer,
Text,
Image,
}

struct Window {
nodes: SlotMap<NodeKey, u32>,
node_kinds: SecondaryMap<NodeKind>
containers: SecondaryMap<FlexContainer>,
text_nodes = SecondaryMap<Text>,
root: NodeKey,
root_taffy: taffy::NodeKey,
taffy_root: taffy::Taffy,
}

let root: NodeKey = todo!();

let mut containers: SecondaryMap<FlexContainer>  = SecondaryMap::new();

impl Window {
fn get_next_key() -> u32 {
todo!()
}

fn set_root(&mut self, &f: FlexContainer) -> NodeKey {
let k = self.nodes.insert(get_next_key());
self.node_kinds.insert(k, NodeKind::FlexContainer);
self.root = k;
k
}

fn create_text(&mut self, t: Text) -> NodeKey {
let k = self.nodes.insert(get_next_key());
self.node_kinds.insert(k, NodeKind::FlexContainer);
self.texts.insert(k, NodeKind::Text);
k
}

fn create_container(
&mut self, c: FlexContainer, children: Vec<NodeKey>
) -> NodeKey {
todo!()
}

fn add_child(&mut self, parent: NodeKey, child: NodeKey) {
match self.containers.get(parent) {
Some(c) => {
c.children.push(child);
self.taffy.add_child(c.taffy, child.taffy);
}
None => panic!();
}
}
}

let mut dc = data_container(win);

let index = dc.create_module();

// -- boolean $open: true

let open = dc.create_mut_boolean(index, true);
let open_ref = dc.get_ref(open);

dc.update_boolean(open, false);

// -- boolean $foo: $open

let foo = dc.create_alias(open);

// -- boolean hello(a):
// boolean a:
//
// !a

let hello_wat = "
fn hello(args: [&Any]) -> Any {
let a = args.0.downcast_ref::<bool>.unwrap();
!a as (dyn Any)
}";

let hello_a = dc.create_boolean_argument();
let hello_return = dc.crate_boolean_return(); // record or enum also supported

let hello = dc.create_function([hello_a], hello_return, hello_wat);

// -- boolean bar = hello(a=$open);

let bar = dc.create_formula(hello, [open_ref]);

// win

let mut win = web::create_root_window();


// -- ftd.text: hello
// color if hello($open): some_fn(red)

let t = win.create_text(Text {
value: "Hello",
..Default::default()
});

let t_color_wat = "

fn t_color(args: [&Any]) -> Any {
let a = args.0.downcast_ref::<bool>.unwrap();
if hello(&Vec::new(a as Any)) {
Some(some_fn(&Vec::new("red" as Any))
} else {
None
} as Any
}";

dc.add_color_dependency(
[open], t, t_color_wat
)


dc.add_mutation(open, t, |node, value| {
if value {
win.set_text_color(node, "red")
}
})

let c = FlexContainer {
gap: Option<usize>,
direction: <>,
children: Vec<NodeKey>,
taffy: taffy::NodeKey,
};

c_id = win.set_root(c);

let t = Text {
value: "hello".to_string(),
// other text related styles
}

t_id = win.create_text_with_parent(t, c_id);