Jonathan Kelley
bdeedc13eb
* feat: wasm-split base implementation * kinda sorta works with the cli * okay great it actually works * fix: cache busting for chunks * cleaned up version * it works with the router * wip: migrate to a faster linear solution using id remapping * add a good harness * it works completely on the docsite * the super tight build works too * make parallelizable * works on the docsite but not the harness * light cleanups, fix for both harness and docsite * make codegen smaller by extract some shared functions to prevent monos * chunking works, but tbd on tuning heuristics * extract used module * wip: cleaning up module * wip: much better understanding of how imports work * fix the call graph * working again... * wip: thinking about ifuncs * ifunc approach works * yes the ifunc approach works!! * it all works completely even with chunks * small cleanups * comments * actually locate all of the symbols * clean up final implementation * clean up tomls, revert some mono changs * clean up, add some more comments / docs in places * hoist more packages * clean up impl a bit more * clean cli * move harness to playwright * update playwright * extract codgen * add lazy to components * Add docs to split loader * clippy * typos * clippy, don't generate splits if not on wasm * whoops, const * Typos and docs * enable optimizations in ci * add optimizations to ci * add wasm-split router feature * parallel playwright? * fix no case check * disable pre-compress... think that might be the issue * better logging, no default pre-compress, caching of shared symbols * Fix: compressing assets * fix non-interactive logging for serve * cache playwright even on failure, use the cli with optimizations * fix prebuild * fix playwright webserver
111 lines
3.3 KiB
Rust
111 lines
3.3 KiB
Rust
use crate::{innerlude::CapturedPanic, ComponentFunction, Element};
|
|
use std::{any::Any, panic::AssertUnwindSafe};
|
|
|
|
pub(crate) type BoxedAnyProps = Box<dyn AnyProps>;
|
|
|
|
/// A trait for a component that can be rendered.
|
|
pub(crate) trait AnyProps: 'static {
|
|
/// Render the component with the internal props.
|
|
fn render(&self) -> Element;
|
|
/// Make the old props equal to the new type erased props. Return if the props were equal and should be memoized.
|
|
fn memoize(&mut self, other: &dyn Any) -> bool;
|
|
/// Get the props as a type erased `dyn Any`.
|
|
fn props(&self) -> &dyn Any;
|
|
/// Get the props as a type erased `dyn Any`.
|
|
fn props_mut(&mut self) -> &mut dyn Any;
|
|
/// Duplicate this component into a new boxed component.
|
|
fn duplicate(&self) -> BoxedAnyProps;
|
|
}
|
|
|
|
/// A component along with the props the component uses to render.
|
|
pub(crate) struct VProps<F: ComponentFunction<P, M>, P, M> {
|
|
render_fn: F,
|
|
memo: fn(&mut P, &P) -> bool,
|
|
props: P,
|
|
name: &'static str,
|
|
phantom: std::marker::PhantomData<M>,
|
|
}
|
|
|
|
impl<F: ComponentFunction<P, M>, P: Clone, M> Clone for VProps<F, P, M> {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
render_fn: self.render_fn.clone(),
|
|
memo: self.memo,
|
|
props: self.props.clone(),
|
|
name: self.name,
|
|
phantom: std::marker::PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<F: ComponentFunction<P, M> + Clone, P: Clone + 'static, M: 'static> VProps<F, P, M> {
|
|
/// Create a [`VProps`] object.
|
|
pub fn new(
|
|
render_fn: F,
|
|
memo: fn(&mut P, &P) -> bool,
|
|
props: P,
|
|
name: &'static str,
|
|
) -> VProps<F, P, M> {
|
|
VProps {
|
|
render_fn,
|
|
memo,
|
|
props,
|
|
name,
|
|
phantom: std::marker::PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<F: ComponentFunction<P, M> + Clone, P: Clone + 'static, M: 'static> AnyProps
|
|
for VProps<F, P, M>
|
|
{
|
|
fn memoize(&mut self, other: &dyn Any) -> bool {
|
|
match other.downcast_ref::<P>() {
|
|
Some(other) => (self.memo)(&mut self.props, other),
|
|
None => false,
|
|
}
|
|
}
|
|
|
|
fn props(&self) -> &dyn Any {
|
|
&self.props
|
|
}
|
|
|
|
fn props_mut(&mut self) -> &mut dyn Any {
|
|
&mut self.props
|
|
}
|
|
|
|
fn render(&self) -> Element {
|
|
fn render_inner(name: &str, res: Result<Element, Box<dyn Any + Send>>) -> Element {
|
|
match res {
|
|
Ok(node) => node,
|
|
Err(err) => {
|
|
// on wasm this massively bloats binary sizes and we can't even capture the panic
|
|
// so do nothing
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
{
|
|
tracing::error!("Panic while rendering component `{name}`: {err:?}");
|
|
}
|
|
Element::Err(CapturedPanic { error: err }.into())
|
|
}
|
|
}
|
|
}
|
|
|
|
render_inner(
|
|
self.name,
|
|
std::panic::catch_unwind(AssertUnwindSafe(move || {
|
|
self.render_fn.rebuild(self.props.clone())
|
|
})),
|
|
)
|
|
}
|
|
|
|
fn duplicate(&self) -> BoxedAnyProps {
|
|
Box::new(Self {
|
|
render_fn: self.render_fn.clone(),
|
|
memo: self.memo,
|
|
props: self.props.clone(),
|
|
name: self.name,
|
|
phantom: std::marker::PhantomData,
|
|
})
|
|
}
|
|
}
|