>,
/// The app's immutable store.
+ #[cfg(not(target_arch = "wasm32"))]
immutable_store: ImmutableStore,
/// The HTML template that'll be used to render the app into. This must be static, but can be generated or sourced in any way. Note that this MUST
/// contain a `` with the `id` set to whatever the value of `self.root` is.
index_view: String,
/// The app's mutable store.
+ #[cfg(not(target_arch = "wasm32"))]
mutable_store: M,
/// The app's translations manager, expressed as a function yielding a `Future`. This is only ever needed on the server-side, and can't be set up properly on the client-side because
/// we can't use futures in the app initialization in Wasm.
+ #[cfg(not(target_arch = "wasm32"))]
translations_manager: Tm,
+ /// The location of the directory to use for static assets that will placed under the URL `/.perseus/static/`. By default, this is the `static/` directory at the root
+ /// of your project. Note that the directory set here will only be used if it exists.
+ #[cfg(not(target_arch = "wasm32"))]
+ static_dir: String,
+ // We need this on the client-side to account for the unused type parameters
+ #[cfg(target_arch = "wasm32")]
+ _marker: PhantomData<(M, T)>,
}
// The usual implementation in which the default mutable store is used
@@ -120,38 +138,57 @@ impl PerseusAppBase {
///
/// This is asynchronous because it creates a translations manager in the background.
// It makes no sense to implement `Default` on this, so we silence Clippy deliberately
+ #[cfg(not(target_arch = "wasm32"))]
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self::new_with_mutable_store(FsMutableStore::new("./dist/mutable".to_string()))
}
+ /// Creates a new instance of a Perseus app using the default filesystem-based mutable store. For most apps, this will be sufficient. Note that this initializes the translations manager
+ /// as a dummy, and adds no templates or error pages.
+ ///
+ /// In development, you can get away with defining no error pages, but production apps (e.g. those created with `perseus deploy`) MUST set their own custom error pages.
+ ///
+ /// This is asynchronous because it creates a translations manager in the background.
+ // It makes no sense to implement `Default` on this, so we silence Clippy deliberately
+ #[cfg(target_arch = "wasm32")]
+ #[allow(clippy::new_without_default)]
+ pub fn new() -> Self {
+ Self::new_wasm()
+ }
}
// If one's using the default translations manager, caching should be handled automatically for them
impl PerseusAppBase {
/// The same as `.locales_and_translations_manager()`, but this accepts a literal `Locales` `struct`, which means this can be used when you're using `FsTranslationsManager` but when you don't
/// know if your app is using i18n or not (almost always middleware).
pub fn locales_lit_and_translations_manager(mut self, locales: Locales) -> Self {
+ #[cfg(not(target_arch = "wasm32"))]
let using_i18n = locales.using_i18n;
+
self.locales = locales;
- // If we're using i18n, do caching stuff
- // If not, use a dummy translations manager
- if using_i18n {
- // By default, all translations are cached
- let all_locales: Vec = self
- .locales
- .get_all()
- .iter()
- // We have a `&&String` at this point, hence the double clone
- .cloned()
- .cloned()
- .collect();
- let tm_fut = FsTranslationsManager::new(
- crate::internal::i18n::DFLT_TRANSLATIONS_DIR.to_string(),
- all_locales,
- crate::internal::i18n::TRANSLATOR_FILE_EXT.to_string(),
- );
- self.translations_manager = Tm::Full(Box::pin(tm_fut));
- } else {
- self.translations_manager = Tm::Dummy(FsTranslationsManager::new_dummy());
+ // We only handle the translations manager on the server-side (it doesn't exist on the client-side)
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ // If we're using i18n, do caching stuff
+ // If not, use a dummy translations manager
+ if using_i18n {
+ // By default, all translations are cached
+ let all_locales: Vec = self
+ .locales
+ .get_all()
+ .iter()
+ // We have a `&&String` at this point, hence the double clone
+ .cloned()
+ .cloned()
+ .collect();
+ let tm_fut = FsTranslationsManager::new(
+ crate::internal::i18n::DFLT_TRANSLATIONS_DIR.to_string(),
+ all_locales,
+ crate::internal::i18n::TRANSLATOR_FILE_EXT.to_string(),
+ );
+ self.translations_manager = Tm::Full(Box::pin(tm_fut));
+ } else {
+ self.translations_manager = Tm::Dummy(FsTranslationsManager::new_dummy());
+ }
}
self
@@ -175,6 +212,7 @@ impl PerseusAppBase {
// The base implementation, generic over the mutable store and translations manager
impl PerseusAppBase {
/// Creates a new instance of a Perseus app, with the default options and a custom mutable store.
+ #[allow(unused_variables)]
pub fn new_with_mutable_store(mutable_store: M) -> Self {
Self {
root: "root".to_string(),
@@ -182,6 +220,7 @@ impl PerseusAppBase {
template_getters: TemplateGetters(Vec::new()),
// We do offer default error pages, but they'll panic if they're called for production building
error_pages: ErrorPagesGetter(Box::new(ErrorPages::default)),
+ #[cfg(not(target_arch = "wasm32"))]
global_state_creator: GlobalStateCreator::default(),
// By default, we'll disable i18n (as much as I may want more websites to support more languages...)
locales: Locales {
@@ -190,15 +229,44 @@ impl PerseusAppBase {
using_i18n: false,
},
// By default, we won't serve any static content outside the `static/` directory
+ #[cfg(not(target_arch = "wasm32"))]
static_aliases: HashMap::new(),
// By default, we won't use any plugins
plugins: Rc::new(Plugins::new()),
- // This is relative to `.perseus/`
+ #[cfg(not(target_arch = "wasm32"))]
immutable_store: ImmutableStore::new("./dist".to_string()),
+ #[cfg(not(target_arch = "wasm32"))]
mutable_store,
+ #[cfg(not(target_arch = "wasm32"))]
translations_manager: Tm::Dummy(T::new_dummy()),
// Many users won't need anything fancy in the index view, so we provide a default
index_view: DFLT_INDEX_VIEW.to_string(),
+ #[cfg(not(target_arch = "wasm32"))]
+ static_dir: "./static".to_string(),
+ #[cfg(target_arch = "wasm32")]
+ _marker: PhantomData,
+ }
+ }
+ /// Internal function for Wasm initialization. This should never be called by the user!
+ #[cfg(target_arch = "wasm32")]
+ fn new_wasm() -> Self {
+ Self {
+ root: "root".to_string(),
+ // We do initialize with no templates, because an app without templates is in theory possible (and it's more convenient to call `.template()` for each one)
+ template_getters: TemplateGetters(Vec::new()),
+ // We do offer default error pages, but they'll panic if they're called for production building
+ error_pages: ErrorPagesGetter(Box::new(ErrorPages::default)),
+ // By default, we'll disable i18n (as much as I may want more websites to support more languages...)
+ locales: Locales {
+ default: "xx-XX".to_string(),
+ other: Vec::new(),
+ using_i18n: false,
+ },
+ // By default, we won't use any plugins
+ plugins: Rc::new(Plugins::new()),
+ // Many users won't need anything fancy in the index view, so we provide a default
+ index_view: DFLT_INDEX_VIEW.to_string(),
+ _marker: PhantomData,
}
}
@@ -208,6 +276,16 @@ impl PerseusAppBase {
self.root = val.to_string();
self
}
+ /// Sets the location of the directory storing static assets to be hosted under the URL `/.perseus/static/`.
+ #[allow(unused_variables)]
+ #[allow(unused_mut)]
+ pub fn static_dir(mut self, val: &str) -> Self {
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ self.static_dir = val.to_string();
+ }
+ self
+ }
/// Sets all the app's templates. This takes a vector of boxed functions that return templates.
pub fn templates(mut self, val: Vec Template>>) -> Self {
self.template_getters.0 = val;
@@ -224,8 +302,13 @@ impl PerseusAppBase {
self
}
/// Sets the app's global state creator.
+ #[allow(unused_variables)]
+ #[allow(unused_mut)]
pub fn global_state_creator(mut self, val: GlobalStateCreator) -> Self {
- self.global_state_creator = val;
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ self.global_state_creator = val;
+ }
self
}
/// Sets the locales information for the app. The first argument is the default locale (used as a fallback for users with no locale preferences set in their browsers), and
@@ -256,8 +339,13 @@ impl PerseusAppBase {
/// When your code is run on the server, the `Future` will be `.await`ed on, but on Wasm, it will be discarded and ignored, since the translations manager isn't needed in Wasm.
///
/// This is generally intended for use with custom translations manager or specific use-cases with the default (mostly to do with custom caching behavior).
+ #[allow(unused_variables)]
+ #[allow(unused_mut)]
pub fn translations_manager(mut self, val: impl Future