feat(homepage): build homepage

Author: fiji-flo

crates/rari-doc/src/build.rs

@@ -7,7 +7,9 @@ use rari_types::globals::build_out_root;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use tracing::{error, span, Level};
 
-use crate::cached_readers::{blog_files, curriculum_files, generic_pages_files};
+use crate::cached_readers::{
+    blog_files, contributor_spotlight_files, curriculum_files, generic_pages_files,
+};
 use crate::error::DocError;
 use crate::pages::build::{
     build_blog_post, build_contributor_spotlight, build_curriculum, build_doc, build_generic_page,
@@ -43,7 +45,7 @@ pub fn build_single_page(page: &Page) {
             serde_json::to_writer(buffed, &built_page).unwrap();
 
             if let Some(in_path) = page.full_path().parent() {
-                copy_additional_files(in_path, &out_path).unwrap();
+                copy_additional_files(in_path, &out_path, page.full_path()).unwrap();
             }
         }
         Err(e) => {
@@ -94,3 +96,24 @@ pub fn build_generic_pages() -> Result<Vec<Cow<'static, str>>, DocError> {
         })
         .collect())
 }
+
+pub fn build_contributor_spotlight_pages() -> Result<Vec<Cow<'static, str>>, DocError> {
+    Ok(contributor_spotlight_files()
+        .values()
+        .map(|page| {
+            build_single_page(page);
+            Cow::Owned(page.url().to_string())
+        })
+        .collect())
+}
+
+pub fn build_spas() -> Result<Vec<Cow<'static, str>>, DocError> {
+    Ok(SPA::all()
+        .iter()
+        .filter_map(|(slug, locale)| SPA::from_slug(slug, *locale))
+        .map(|page| {
+            build_single_page(&page);
+            Cow::Owned(page.url().to_string())
+        })
+        .collect())
+}

crates/rari-doc/src/cached_readers.rs

@@ -4,8 +4,8 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, LazyLock, OnceLock, RwLock};
 
 use rari_types::globals::{
-    blog_root, cache_content, content_root, content_translated_root, curriculum_root,
-    generic_pages_root,
+    blog_root, cache_content, content_root, content_translated_root, contributor_spotlight_root,
+    curriculum_root, generic_pages_root,
 };
 use rari_types::locale::Locale;
 use rari_utils::io::read_to_string;
@@ -15,6 +15,7 @@ use crate::error::DocError;
 use crate::html::sidebar::{MetaSidebar, Sidebar};
 use crate::pages::page::{Page, PageLike};
 use crate::pages::types::blog::{Author, AuthorFrontmatter, BlogPost, BlogPostBuildMeta};
+use crate::pages::types::contributors::ContributorSpotlight;
 use crate::pages::types::curriculum::{CurriculumIndexEntry, CurriculumPage};
 use crate::pages::types::doc::Doc;
 use crate::pages::types::generic::GenericPage;
@@ -31,7 +32,8 @@ type SidebarFilesCache = Arc<RwLock<HashMap<(String, Locale), Arc<MetaSidebar>>>
 pub static CACHED_SIDEBAR_FILES: LazyLock<SidebarFilesCache> =
     LazyLock::new(|| Arc::new(RwLock::new(HashMap::new())));
 pub static CACHED_CURRICULUM: OnceLock<CurriculumFiles> = OnceLock::new();
-pub static GENERIC_PAGES_FILES: OnceLock<GenericPagesFiles> = OnceLock::new();
+pub static GENERIC_PAGES_FILES: OnceLock<UrlToPageMap> = OnceLock::new();
+pub static CONTRIBUTOR_SPOTLIGHT_FILES: OnceLock<UrlToPageMap> = OnceLock::new();
 
 #[derive(Debug, Default, Clone)]
 pub struct BlogFiles {
@@ -177,6 +179,30 @@ pub fn gather_curriculum() -> Result<CurriculumFiles, DocError> {
     }
 }
 
+pub fn gather_contributre_spotlight() -> Result<HashMap<String, Page>, DocError> {
+    if let Some(root) = contributor_spotlight_root() {
+        Ok(read_docs_parallel::<ContributorSpotlight>(&[root], None)?
+            .into_iter()
+            .filter_map(|page| {
+                if let Page::ContributorSpotlight(cs) = page {
+                    Some(cs)
+                } else {
+                    None
+                }
+            })
+            .flat_map(|cs| {
+                Locale::all()
+                    .iter()
+                    .map(|locale| Page::ContributorSpotlight(Arc::new(cs.as_locale(*locale))))
+                    .collect::<Vec<_>>()
+            })
+            .map(|page| (page.url().to_ascii_lowercase(), page))
+            .collect())
+    } else {
+        Err(DocError::NoGenericPagesRoot)
+    }
+}
+
 pub fn curriculum_files() -> Cow<'static, CurriculumFiles> {
     if cache_content() {
         Cow::Borrowed(CACHED_CURRICULUM.get_or_init(|| {
@@ -303,10 +329,10 @@ pub fn read_and_cache_doc_pages() -> Result<Vec<Page>, DocError> {
     Ok(docs)
 }
 
-pub type GenericPagesFiles = HashMap<String, Page>;
+pub type UrlToPageMap = HashMap<String, Page>;
 
-pub fn generic_pages_files() -> Cow<'static, GenericPagesFiles> {
-    fn gather() -> GenericPagesFiles {
+pub fn generic_pages_files() -> Cow<'static, UrlToPageMap> {
+    fn gather() -> UrlToPageMap {
         gather_generic_pages().unwrap_or_else(|e| {
             error!("{e}");
             Default::default()
@@ -318,3 +344,17 @@ pub fn generic_pages_files() -> Cow<'static, GenericPagesFiles> {
         Cow::Owned(gather())
     }
 }
+
+pub fn contributor_spotlight_files() -> Cow<'static, UrlToPageMap> {
+    fn gather() -> UrlToPageMap {
+        gather_contributre_spotlight().unwrap_or_else(|e| {
+            error!("{e}");
+            Default::default()
+        })
+    }
+    if cache_content() {
+        Cow::Borrowed(CONTRIBUTOR_SPOTLIGHT_FILES.get_or_init(gather))
+    } else {
+        Cow::Owned(gather())
+    }
+}

crates/rari-doc/src/html/rewriter.rs

@@ -7,6 +7,7 @@ use rari_l10n::l10n_json_data;
 use rari_md::node_card::NoteCard;
 use rari_types::fm_types::PageType;
 use rari_types::locale::Locale;
+use tracing::warn;
 use url::Url;
 
 use crate::error::DocError;
@@ -85,20 +86,28 @@ pub fn post_process_html<T: PageLike>(
                     el.set_attribute("src", url.path())?;
                     let file = page.full_path().parent().unwrap().join(&src);
                     let (width, height) = if src.ends_with(".svg") {
-                        let meta = svg_metadata::Metadata::parse_file(&file)?;
-                        (
-                            meta.width
-                                .map(|width| width.width)
-                                .or(meta.view_box.map(|vb| vb.width))
-                                .map(|width| format!("{:.0}", width)),
-                            meta.height
-                                .map(|height| height.height)
-                                .or(meta.view_box.map(|vb| vb.height))
-                                .map(|height| format!("{:.0}", height)),
-                        )
-                    } else {
-                        let dim = imagesize::size(&file)?;
+                        match svg_metadata::Metadata::parse_file(&file) {
+                            Ok(meta) => (
+                                meta.width
+                                    .map(|width| width.width)
+                                    .or(meta.view_box.map(|vb| vb.width))
+                                    .map(|width| format!("{:.0}", width)),
+                                meta.height
+                                    .map(|height| height.height)
+                                    .or(meta.view_box.map(|vb| vb.height))
+                                    .map(|height| format!("{:.0}", height)),
+                            ),
+                            Err(e) => {
+                                warn!("Error parsing {}: {e}", file.display());
+                                (None, None)
+                            }
+                        }
+                    } else if let Ok(dim) = imagesize::size(&file)
+                        .inspect_err(|e| warn!("Error opening {}: {e}", file.display()))
+                    {
                         (Some(dim.width.to_string()), Some(dim.height.to_string()))
+                    } else {
+                        (None, None)
                     };
                     if let Some(width) = width {
                         el.set_attribute("width", &width)?;
@@ -143,7 +152,7 @@ pub fn post_process_html<T: PageLike>(
                     el.set_attribute("aria-current", "page")?;
                 }
                 if !Page::exists(resolved_href_no_hash) && !Page::ignore(href) {
-                    tracing::info!("{resolved_href_no_hash} {href}");
+                    tracing::debug!("{resolved_href_no_hash} {href}");
                     let class = el.get_attribute("class").unwrap_or_default();
                     el.set_attribute(
                         "class",

crates/rari-doc/src/pages/build.rs

@@ -157,6 +157,7 @@ pub fn build_content<T: PageLike>(page: &T) -> Result<PageContent, DocError> {
     let encoded_html = render_md_to_html(&ks_rendered_doc, page.locale())?;
     let html = decode_ref(&encoded_html, &templs)?;
     let post_processed_html = post_process_html(&html, page, false)?;
+
     let mut fragment = Html::parse_fragment(&post_processed_html);
     if page.page_type() == PageType::Curriculum {
         bubble_up_curriculum_page(&mut fragment)?;
@@ -322,7 +323,8 @@ pub fn build_blog_post(post: &BlogPost) -> Result<BuiltDocy, DocError> {
 }
 
 pub fn build_generic_page(page: &GenericPage) -> Result<BuiltDocy, DocError> {
-    let PageContent { body, toc, .. } = build_content(page)?;
+    let built = build_content(page);
+    let PageContent { body, toc, .. } = built?;
     Ok(BuiltDocy::GenericPage(Box::new(JsonGenericPage {
         hy_data: JsonGenericHyData {
             sections: body,
@@ -399,11 +401,11 @@ pub fn build_contributor_spotlight(cs: &ContributorSpotlight) -> Result<BuiltDoc
     )))
 }
 
-pub fn copy_additional_files(from: &Path, to: &Path) -> Result<(), DocError> {
+pub fn copy_additional_files(from: &Path, to: &Path, ignore: &Path) -> Result<(), DocError> {
     for from in fs::read_dir(from)?
         .filter_map(Result::ok)
         .map(|f| f.path())
-        .filter(|p| p.is_file())
+        .filter(|p| p.is_file() && p != ignore)
     {
         if let Some(filename) = from.file_name() {
             let to = to.to_path_buf().join(filename);

crates/rari-doc/src/pages/json.rs

@@ -1,14 +1,13 @@
 use std::path::PathBuf;
 
-use chrono::NaiveDateTime;
+use chrono::{DateTime, NaiveDate, NaiveDateTime, Utc};
 use rari_data::baseline::SupportStatusWithByKey;
 use rari_types::locale::{Locale, Native};
 use serde::{Deserialize, Serialize};
 
 use super::types::contributors::Usernames;
 use super::types::curriculum::{CurriculumIndexEntry, CurriculumSidebarEntry, Template, Topic};
 use crate::pages::types::blog::BlogMeta;
-use crate::pages::types::spa::BlogIndex;
 use crate::specs::Specification;
 use crate::utils::modified_dt;
 
@@ -117,6 +116,11 @@ pub struct JsonDoc {
     pub browser_compat: Vec<String>,
 }
 
+#[derive(Debug, Clone, Serialize)]
+pub struct BlogIndex {
+    pub posts: Vec<BlogMeta>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 #[serde(untagged)]
 pub enum HyData {
@@ -246,6 +250,7 @@ pub enum BuiltDocy {
     ContributorSpotlight(Box<JsonContributorSpotlight>),
     BasicSPA(Box<JsonBasicSPA>),
     GenericPage(Box<JsonGenericPage>),
+    HomePageSPA(Box<JsonHomePageSPA>),
 }
 
 #[derive(Deserialize, Serialize, Clone, Debug, Default)]
@@ -285,12 +290,72 @@ pub struct UrlNTitle {
 pub struct JsonBasicSPA {
     pub slug: &'static str,
     pub page_title: &'static str,
-    pub page_description: &'static str,
+    pub page_description: Option<&'static str>,
     pub only_follow: bool,
     pub no_indexing: bool,
     pub url: String,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HomePageFeaturedArticle {
+    pub mdn_url: String,
+    pub summay: String,
+    pub title: String,
+    pub tag: Option<Parent>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HomePageFeaturedContributor {
+    pub contributor_name: String,
+    pub url: String,
+    pub quote: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct NameUrl {
+    pub name: String,
+    pub url: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct HomePageLatestNewsItem {
+    pub url: String,
+    pub title: String,
+    pub author: Option<String>,
+    pub source: NameUrl,
+    pub published_at: NaiveDate,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct HomePageRecentContribution {
+    pub number: i64,
+    pub title: String,
+    pub updated_at: DateTime<Utc>,
+    pub url: String,
+    pub repo: NameUrl,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ItemContainer<T>
+where
+    T: Clone + Serialize,
+{
+    pub items: Vec<T>,
+}
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JsonHomePageSPA {
+    pub slug: &'static str,
+    pub page_title: &'static str,
+    pub page_description: Option<&'static str>,
+    pub featured_articles: Vec<HomePageFeaturedArticle>,
+    pub featured_contributor: Option<HomePageFeaturedContributor>,
+    pub latest_news: ItemContainer<HomePageLatestNewsItem>,
+    pub recent_contributions: ItemContainer<HomePageRecentContribution>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsonGenericHyData {

crates/rari-doc/src/pages/types/contributors.rs

@@ -2,7 +2,6 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use concat_in_place::strcat;
-use constcat::concat;
 use rari_md::m2h;
 use rari_types::error::EnvError;
 use rari_types::fm_types::{FeatureStatus, PageType};
@@ -135,6 +134,23 @@ pub struct ContributorSpotlight {
     content_start: usize,
 }
 
+impl ContributorSpotlight {
+    pub fn as_locale(&self, locale: Locale) -> Self {
+        let Self {
+            mut meta,
+            raw,
+            content_start,
+        } = self.clone();
+        meta.locale = locale;
+        meta.url = strcat!("/" locale.as_url_str() "/community/" meta.slug.as_str());
+        Self {
+            meta,
+            raw,
+            content_start,
+        }
+    }
+}
+
 impl PageReader for ContributorSpotlight {
     fn read(path: impl Into<PathBuf>, locale: Option<Locale>) -> Result<Page, DocError> {
         read_contributor_spotlight(path, locale.unwrap_or_default())
@@ -206,7 +222,7 @@ impl PageLike for ContributorSpotlight {
     }
 
     fn base_slug(&self) -> &str {
-        concat!("/", Locale::EnUs.as_url_str(), "/")
+        "/en-US/"
     }
 
     fn trailing_slash(&self) -> bool {

crates/rari-doc/src/pages/types/generic.rs

@@ -92,14 +92,14 @@ impl GenericPage {
     }
 
     pub fn as_locale(&self, locale: Locale) -> Self {
-        let GenericPage {
+        let Self {
             mut meta,
             raw,
             content_start,
         } = self.clone();
         meta.locale = locale;
         meta.url = strcat!("/" locale.as_url_str() "/" meta.slug.as_str());
-        GenericPage {
+        Self {
             meta,
             raw,
             content_start,

crates/rari-doc/src/pages/types/mod.rs

@@ -4,3 +4,4 @@ pub mod curriculum;
 pub mod doc;
 pub mod generic;
 pub mod spa;
+pub mod spa_homepage;

crates/rari-doc/src/pages/types/spa.rs

@@ -6,25 +6,33 @@ use concat_in_place::strcat;
 use constcat::concat;
 use phf::{phf_map, Map};
 use rari_types::fm_types::{FeatureStatus, PageType};
+use rari_types::globals::content_translated_root;
 use rari_types::locale::Locale;
 use rari_types::RariEnv;
-use serde::Serialize;
 
+use super::spa_homepage::{
+    featured_articles, featured_contributor, lastet_news, recent_contributions,
+};
 use crate::cached_readers::blog_files;
 use crate::error::DocError;
-use crate::pages::json::{BuiltDocy, HyData, JsonBasicSPA, JsonBlogPost, JsonBlogPostDoc};
+use crate::pages::json::{
+    BlogIndex, BuiltDocy, HyData, ItemContainer, JsonBasicSPA, JsonBlogPost, JsonBlogPostDoc,
+    JsonHomePageSPA,
+};
 use crate::pages::page::{Page, PageLike, PageReader};
 use crate::pages::title::page_title;
 use crate::pages::types::blog::BlogMeta;
 
-#[derive(Debug, Clone, Serialize)]
-pub struct BlogIndex {
-    pub posts: Vec<BlogMeta>,
+#[derive(Debug, Clone, Copy)]
+pub struct BasicSPA {
+    pub only_follow: bool,
+    pub no_indexing: bool,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub enum SPAData {
-    BlogIndex(BlogIndex),
+    BlogIndex,
+    HomePage,
     BasicSPA(BasicSPA),
 }
 
@@ -35,8 +43,9 @@ pub struct SPA {
     pub url: String,
     pub locale: Locale,
     pub page_type: PageType,
-    pub typ: SPAData,
+    pub data: SPAData,
     pub base_slug: Cow<'static, str>,
+    pub page_description: Option<&'static str>,
 }
 impl SPA {
     pub fn from_url(url: &str) -> Option<Page> {
@@ -45,50 +54,46 @@ impl SPA {
             _ => None,
         }
     }
+
     pub fn from_slug(slug: &str, locale: Locale) -> Option<Page> {
-        if let Some(basic_spa) = BASIC_SPAS.get(slug) {
-            return Some(Page::SPA(Arc::new(SPA {
-                page_title: basic_spa.page_title,
-                slug: basic_spa.slug,
-                url: strcat!("/" locale.as_url_str() basic_spa.slug),
+        BASIC_SPAS.get(slug).and_then(|build_spa| {
+            if build_spa.en_us_only && locale != Locale::EnUs { None } else {
+            Some(Page::SPA(Arc::new(SPA {
+                page_title: build_spa.page_title,
+                slug: build_spa.slug,
+                url: strcat!("/" locale.as_url_str() "/" build_spa.slug if build_spa.trailing_slash { "/" } else { "" }),
                 locale,
                 page_type: PageType::SPA,
-                typ: SPAData::BasicSPA(*basic_spa),
+                data: build_spa.data,
                 base_slug: Cow::Owned(strcat!("/" locale.as_url_str() "/")),
-            })));
-        }
-        match (slug, locale) {
-            ("blog" | "blog/", Locale::EnUs) => Some(Page::SPA(Arc::new(SPA {
-                page_title: "MDN Blog",
-                slug: "blog",
-                url: "/en-US/blog/".to_string(),
-                locale: Locale::EnUs,
-                page_type: PageType::SPA,
-                typ: SPAData::BlogIndex(BlogIndex {
-                    posts: blog_files()
-                        .sorted_meta
-                        .iter()
-                        .rev()
-                        .map(BlogMeta::from)
-                        .map(|mut m| {
-                            m.links = Default::default();
-                            m
-                        })
-                        .collect(),
-                }),
-                base_slug: Cow::Borrowed(concat!("/", Locale::EnUs.as_url_str(), "/")),
-            }))),
-            _ => None,
-        }
+                page_description: build_spa.page_description,
+            })))}
+        })
     }
 
     pub fn is_spa(slug: &str, locale: Locale) -> bool {
-        BASIC_SPAS.contains_key(slug) || matches!((slug, locale), ("blog" | "blog/", Locale::EnUs))
+        BASIC_SPAS
+            .get(slug)
+            .map(|build_spa| locale == Default::default() || !build_spa.en_us_only)
+            .unwrap_or_default()
+    }
+
+    pub fn all() -> Vec<(&'static &'static str, Locale)> {
+        BASIC_SPAS
+            .entries()
+            .flat_map(|(slug, build_spa)| {
+                if build_spa.en_us_only || content_translated_root().is_none() {
+                    vec![(slug, Locale::EnUs)]
+                } else {
+                    Locale::all().iter().map(|locale| (slug, *locale)).collect()
+                }
+            })
+            .collect()
     }
 
     pub fn as_built_doc(&self) -> Result<BuiltDocy, DocError> {
-        match &self.typ {
-            SPAData::BlogIndex(b) => Ok(BuiltDocy::BlogPost(Box::new(JsonBlogPost {
+        match &self.data {
+            SPAData::BlogIndex => Ok(BuiltDocy::BlogPost(Box::new(JsonBlogPost {
                 doc: JsonBlogPostDoc {
                     title: self.title().to_string(),
                     mdn_url: self.url().to_owned(),
@@ -100,18 +105,55 @@ impl SPA {
                 url: self.url().to_owned(),
                 locale: self.locale(),
                 blog_meta: None,
-                hy_data: Some(HyData::BlogIndex(b.clone())),
+                hy_data: Some(HyData::BlogIndex(BlogIndex {
+                    posts: blog_files()
+                        .sorted_meta
+                        .iter()
+                        .rev()
+                        .map(BlogMeta::from)
+                        .map(|mut m| {
+                            m.links = Default::default();
+                            m
+                        })
+                        .collect(),
+                })),
                 page_title: self.title().to_owned(),
                 ..Default::default()
             }))),
             SPAData::BasicSPA(basic_spa) => Ok(BuiltDocy::BasicSPA(Box::new(JsonBasicSPA {
                 slug: self.slug,
                 page_title: self.page_title,
-                page_description: basic_spa.page_description,
+                page_description: self.page_description,
                 only_follow: basic_spa.only_follow,
                 no_indexing: basic_spa.no_indexing,
                 url: strcat!(self.base_slug.as_ref() self.slug),
             }))),
+            SPAData::HomePage => Ok(BuiltDocy::HomePageSPA(Box::new(JsonHomePageSPA {
+                slug: self.slug,
+                page_title: self.page_title,
+                page_description: self.page_description,
+                featured_articles: featured_articles(
+                    &[
+                        "/en-US/blog/mdn-scrimba-partnership/",
+                        "/en-US/blog/learn-javascript-console-methods/",
+                        "/en-US/blog/introduction-to-web-sustainability/",
+                        "/en-US/docs/Web/API/CSS_Custom_Highlight_API",
+                    ],
+                    self.locale,
+                )?,
+                featured_contributor: featured_contributor(self.locale)?,
+                latest_news: ItemContainer {
+                    items: lastet_news(&[
+                        "/en-US/blog/mdn-scrimba-partnership/",
+                        "/en-US/blog/mdn-http-observatory-launch/",
+                        "/en-US/blog/mdn-curriculum-launch/",
+                        "/en-US/blog/baseline-evolution-on-mdn/",
+                    ])?,
+                },
+                recent_contributions: ItemContainer {
+                    items: recent_contributions()?,
+                },
+            }))),
         }
     }
 }
@@ -184,115 +226,136 @@ impl PageLike for SPA {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default)]
-pub struct BasicSPA {
+#[derive(Debug, Clone, Copy)]
+pub struct BuildSPA {
     pub slug: &'static str,
     pub page_title: &'static str,
-    pub page_description: &'static str,
-    pub only_follow: bool,
-    pub no_indexing: bool,
+    pub page_description: Option<&'static str>,
+    pub trailing_slash: bool,
+    pub en_us_only: bool,
+    pub data: SPAData,
 }
 
-const DEFAULT_BASIC_SPA: BasicSPA = BasicSPA {
+const DEFAULT_BASIC_SPA: BuildSPA = BuildSPA {
     slug: "",
     page_title: "",
-    page_description: "",
-    only_follow: false,
-    no_indexing: false,
+    page_description: None,
+    trailing_slash: false,
+    en_us_only: false,
+    data: SPAData::BasicSPA(BasicSPA {
+        only_follow: false,
+        no_indexing: false,
+    }),
 };
 
 const MDN_PLUS_TITLE: &str = "MDN Plus";
 const OBSERVATORY_TITLE_FULL: &str = "HTTP Observatory | MDN";
 
-const OBSERVATORY_DESCRIPTION: &str =
-"Test your site’s HTTP headers, including CSP and HSTS, to find security problems and get actionable recommendations to make your website more secure. Test other websites to see how you compare.";
+const OBSERVATORY_DESCRIPTION: Option<&str> =
+Some("Test your site’s HTTP headers, including CSP and HSTS, to find security problems and get actionable recommendations to make your website more secure. Test other websites to see how you compare.");
 
-static BASIC_SPAS: Map<&'static str, BasicSPA> = phf_map!(
-    "play" => BasicSPA {
+static BASIC_SPAS: Map<&'static str, BuildSPA> = phf_map!(
+    "" => BuildSPA {
+        slug: "",
+        page_title: "MDN Web Docs",
+        page_description: None,
+        trailing_slash: true,
+        data: SPAData::HomePage,
+        ..DEFAULT_BASIC_SPA
+    },
+    "blog" => BuildSPA {
+        slug: "blog",
+        page_title: "MDN Blog",
+        page_description: None,
+        trailing_slash: true,
+        en_us_only: true,
+        data: SPAData::BlogIndex
+    },
+    "play" => BuildSPA {
         slug: "play",
         page_title: "Playground | MDN",
         ..DEFAULT_BASIC_SPA
     },
-    "observatory" => BasicSPA {
+    "observatory" => BuildSPA {
         slug: "observatory",
         page_title: concat!("HTTP Header Security Test - ", OBSERVATORY_TITLE_FULL),
         page_description: OBSERVATORY_DESCRIPTION,
         ..DEFAULT_BASIC_SPA
     },
-    "observatory/analyze" => BasicSPA {
+    "observatory/analyze" => BuildSPA {
         slug: "observatory/analyze",
         page_title: concat!("Scan results - ", OBSERVATORY_TITLE_FULL),
         page_description: OBSERVATORY_DESCRIPTION,
-        no_indexing: true,
+        data: SPAData::BasicSPA(BasicSPA { no_indexing: true, only_follow: false }),
         ..DEFAULT_BASIC_SPA
     },
-    "observatory/docs/tests_and_scoring" => BasicSPA {
+    "observatory/docs/tests_and_scoring" => BuildSPA {
         slug: "observatory/docs/tests_and_scoring",
         page_title: concat!("Tests & Scoring - ", OBSERVATORY_TITLE_FULL),
         page_description: OBSERVATORY_DESCRIPTION,
         ..DEFAULT_BASIC_SPA
     },
-    "observatory/docs/faq" => BasicSPA {
+    "observatory/docs/faq" => BuildSPA {
         slug: "observatory/docs/faq",
         page_title: concat!("FAQ - ", OBSERVATORY_TITLE_FULL),
         page_description: OBSERVATORY_DESCRIPTION,
         ..DEFAULT_BASIC_SPA
     },
-    "search" => BasicSPA {
+    "search" => BuildSPA {
         slug: "search",
         page_title: "Search",
-        only_follow: true,
+        data: SPAData::BasicSPA(BasicSPA { only_follow: true, no_indexing: false }),
         ..DEFAULT_BASIC_SPA
     },
-    "plus" => BasicSPA {
+    "plus" => BuildSPA {
         slug: "plus",
         page_title: MDN_PLUS_TITLE,
         ..DEFAULT_BASIC_SPA
     },
-    "plus/ai-help" => BasicSPA {
+    "plus/ai-help" => BuildSPA {
         slug: "plus/ai-help",
         page_title: concat!("AI Help | ", MDN_PLUS_TITLE),
         ..DEFAULT_BASIC_SPA
     },
-    "plus/collections" => BasicSPA {
+    "plus/collections" => BuildSPA {
         slug: "plus/collections",
         page_title: concat!("Collections | ", MDN_PLUS_TITLE),
-        no_indexing: true,
+        data: SPAData::BasicSPA(BasicSPA { no_indexing: true, only_follow: false }),
         ..DEFAULT_BASIC_SPA
     },
-    "plus/collections/frequently_viewed" => BasicSPA {
+    "plus/collections/frequently_viewed" => BuildSPA {
         slug: "plus/collections/frequently_viewed",
         page_title: concat!("Frequently viewed articles | ", MDN_PLUS_TITLE),
-        no_indexing: true,
+        data: SPAData::BasicSPA(BasicSPA { no_indexing: true, only_follow: false }),
         ..DEFAULT_BASIC_SPA
     },
-    "plus/updates" => BasicSPA {
+    "plus/updates" => BuildSPA {
         slug: "plus/updates",
         page_title: concat!("Updates | ", MDN_PLUS_TITLE),
         ..DEFAULT_BASIC_SPA
     },
-    "plus/settings" => BasicSPA {
+    "plus/settings" => BuildSPA {
         slug: "plus/settings",
         page_title: concat!("Settings | ", MDN_PLUS_TITLE),
-        no_indexing: true,
+        data: SPAData::BasicSPA(BasicSPA { no_indexing: true, only_follow: false }),
         ..DEFAULT_BASIC_SPA
     },
-    "about" => BasicSPA {
+    "about" => BuildSPA {
         slug: "about",
         page_title: "About MDN",
         ..DEFAULT_BASIC_SPA
     },
-    "community" => BasicSPA {
+    "community" => BuildSPA {
         slug: "community",
         page_title: "Contribute to MDN",
         ..DEFAULT_BASIC_SPA
     },
-    "advertising" => BasicSPA {
+    "advertising" => BuildSPA {
         slug: "advertising",
         page_title: "Advertise with us",
         ..DEFAULT_BASIC_SPA
     },
-    "newsletter" => BasicSPA {
+    "newsletter" => BuildSPA {
         slug: "newsletter",
         page_title: "Stay Informed with MDN",
         ..DEFAULT_BASIC_SPA

crates/rari-doc/src/pages/types/spa_homepage.rs

@@ -0,0 +1,160 @@
+use std::path::Path;
+use std::process::Command;
+use std::sync::LazyLock;
+
+use chrono::{DateTime, Utc};
+use concat_in_place::strcat;
+use rari_types::globals::{content_root, content_translated_root};
+use rari_types::locale::Locale;
+use regex::Regex;
+
+use crate::cached_readers::contributor_spotlight_files;
+use crate::error::DocError;
+use crate::helpers::summary_hack::get_hacky_summary_md;
+use crate::pages::json::{
+    HomePageFeaturedArticle, HomePageFeaturedContributor, HomePageLatestNewsItem,
+    HomePageRecentContribution, NameUrl, Parent,
+};
+use crate::pages::page::{url_path_to_page_with_other_locale_and_fallback, Page, PageLike};
+use crate::pages::parents::parents;
+
+pub fn lastet_news(urls: &[&str]) -> Result<Vec<HomePageLatestNewsItem>, DocError> {
+    urls.iter()
+        .filter_map(|url| match Page::page_from_url_path(url) {
+            Ok(Page::BlogPost(post)) => Some(Ok(HomePageLatestNewsItem {
+                url: post.url().to_string(),
+                title: post.title().to_string(),
+                author: Some(post.meta.author.clone()),
+                source: NameUrl {
+                    name: "developer.mozilla.org".to_string(),
+                    url: strcat!("/" Locale::default().as_url_str() "/blog/"),
+                },
+                published_at: post.meta.date,
+            })),
+            Err(e) => Some(Err(e)),
+            x => {
+                tracing::debug!("{x:?}");
+                None
+            }
+        })
+        .collect()
+}
+
+pub fn featured_articles(
+    urls: &[&str],
+    locale: Locale,
+) -> Result<Vec<HomePageFeaturedArticle>, DocError> {
+    urls.iter()
+        .filter_map(|url| {
+            match url_path_to_page_with_other_locale_and_fallback(url, Some(locale)) {
+                Ok(Page::BlogPost(post)) => Some(Ok(HomePageFeaturedArticle {
+                    mdn_url: post.url().to_string(),
+                    summay: post.meta.description.clone(),
+                    title: post.title().to_string(),
+                    tag: Some(Parent {
+                        uri: strcat!("/" Locale::default().as_url_str() "/blog/"),
+                        title: "Blog".to_string(),
+                    }),
+                })),
+                Ok(ref page @ Page::Doc(ref doc)) => Some(Ok(HomePageFeaturedArticle {
+                    mdn_url: doc.url().to_string(),
+                    summay: get_hacky_summary_md(page).unwrap_or_default(),
+                    title: doc.title().to_string(),
+                    tag: parents(page).get(1).cloned(),
+                })),
+                Err(e) => Some(Err(e)),
+                x => {
+                    tracing::debug!("{x:?}");
+                    None
+                }
+            }
+        })
+        .collect()
+}
+
+pub fn recent_contributions() -> Result<Vec<HomePageRecentContribution>, DocError> {
+    let mut content = recent_contributions_from_git(content_root(), "mdn/content")?;
+    if let Some(translated_root) = content_translated_root() {
+        content.extend(recent_contributions_from_git(
+            translated_root,
+            "mdn/translated_content",
+        )?);
+    };
+    content.sort_by(|a, b| a.updated_at.cmp(&b.updated_at));
+    Ok(content)
+}
+
+static GIT_LOG_LINE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r#"^(?<date>[^ ]+) (?<msg>.*[^\)])( \(#(?<pr>\d+)\))?$"#).unwrap());
+
+fn recent_contributions_from_git(
+    path: &Path,
+    repo: &str,
+) -> Result<Vec<HomePageRecentContribution>, DocError> {
+    let output = Command::new("git")
+        .args(["rev-parse", "--show-toplevel"])
+        .current_dir(path)
+        .output()
+        .expect("failed to execute git rev-parse");
+
+    let repo_root_raw = String::from_utf8_lossy(&output.stdout);
+    let repo_root = repo_root_raw.trim();
+
+    let output = Command::new("git")
+        .args([
+            "log",
+            "--no-merges",
+            "--pretty=format:%aI %s",
+            "-n 10",
+            "-z",
+        ])
+        .current_dir(repo_root)
+        .output()
+        .expect("failed to execute process");
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+    Ok(output_str
+        .split(['\0'])
+        .filter_map(|line| {
+            GIT_LOG_LINE.captures(line.trim()).and_then(|cap| {
+                match (cap.name("date"), cap.name("msg"), cap.name("pr")) {
+                    (Some(date), Some(msg), Some(pr)) => Some(HomePageRecentContribution {
+                        number: pr.as_str().parse::<i64>().unwrap_or_default(),
+                        title: msg.as_str().to_string(),
+                        updated_at: date.as_str().parse::<DateTime<Utc>>().unwrap_or_default(),
+                        url: strcat!("https://github.com/" repo "/pull/" pr.as_str()),
+                        repo: NameUrl {
+                            name: repo.to_string(),
+                            url: strcat!("https://github.com/" repo),
+                        },
+                    }),
+                    _ => None,
+                }
+            })
+        })
+        .take(5)
+        .collect())
+}
+
+pub fn featured_contributor(
+    locale: Locale,
+) -> Result<Option<HomePageFeaturedContributor>, DocError> {
+    Ok(contributor_spotlight_files()
+        .values()
+        .find_map(|cs| {
+            if let Page::ContributorSpotlight(cs) = cs {
+                if cs.meta.is_featured && cs.locale() == locale {
+                    Some(cs)
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        })
+        .map(|cs| HomePageFeaturedContributor {
+            contributor_name: cs.meta.contributor_name.clone(),
+            url: cs.url().to_string(),
+            quote: cs.meta.quote.clone(),
+        }))
+}

crates/rari-doc/src/resolve.rs

@@ -37,7 +37,7 @@ pub fn url_path_to_path_buf(
     let tail: Vec<_> = split.collect();
     let (typ, slug) = match tail.as_slice() {
         ["docs", tail] => (PageCategory::Doc, *tail),
-        ["blog"] if locale == Default::default() => (PageCategory::SPA, Default::default()),
+        ["blog"] | ["blog", ""] if locale == Default::default() => (PageCategory::SPA, "blog"),
         ["blog", tail] if locale == Default::default() => (PageCategory::BlogPost, *tail),
         ["curriculum", tail] if locale == Default::default() => (PageCategory::Curriculum, *tail),
         ["community", tail] if locale == Default::default() && tail.starts_with("spotlight") => {
@@ -47,7 +47,6 @@ pub fn url_path_to_path_buf(
         _ => {
             let (_, slug) = strip_locale_from_url(url_path);
             let slug = slug.strip_prefix('/').unwrap_or(slug);
-            println!("{slug}");
             if SPA::is_spa(slug, locale) {
                 (PageCategory::SPA, slug)
             } else if GenericPage::is_generic(slug, locale) {

crates/rari-types/src/locale.rs

@@ -5,6 +5,8 @@ use serde::{Deserialize, Serialize};
 use serde_variant::to_variant_name;
 use thiserror::Error;
 
+use crate::globals::content_translated_root;
+
 #[derive(PartialEq, Debug, Clone, Copy, Deserialize, Serialize, Default, PartialOrd, Eq, Ord)]
 pub enum Native {
     #[default]
@@ -108,18 +110,22 @@ impl Locale {
         }
     }
 
-    pub const fn all() -> &'static [Self] {
-        &[
-            Self::EnUs,
-            Self::Es,
-            Self::Fr,
-            Self::Ja,
-            Self::Ko,
-            Self::PtBr,
-            Self::Ru,
-            Self::ZhCn,
-            Self::ZhTw,
-        ]
+    pub fn all() -> &'static [Self] {
+        if content_translated_root().is_some() {
+            &[
+                Self::EnUs,
+                Self::Es,
+                Self::Fr,
+                Self::Ja,
+                Self::Ko,
+                Self::PtBr,
+                Self::Ru,
+                Self::ZhCn,
+                Self::ZhTw,
+            ]
+        } else {
+            &[Self::EnUs]
+        }
     }
 }
 

src/main.rs

@@ -7,7 +7,10 @@ use std::sync::{Arc, RwLock};
 use std::thread::spawn;
 
 use clap::{Args, Parser, Subcommand};
-use rari_doc::build::{build_blog_pages, build_curriculum_pages, build_docs, build_generic_pages};
+use rari_doc::build::{
+    build_blog_pages, build_contributor_spotlight_pages, build_curriculum_pages, build_docs,
+    build_generic_pages, build_spas,
+};
 use rari_doc::cached_readers::{read_and_cache_doc_pages, CACHED_DOC_PAGE_FILES};
 use rari_doc::pages::types::doc::Doc;
 use rari_doc::reader::read_docs_parallel;
@@ -65,6 +68,8 @@ struct BuildArgs {
     #[arg(long)]
     skip_content: bool,
     #[arg(long)]
+    skip_contributors: bool,
+    #[arg(long)]
     skip_blog: bool,
     #[arg(long)]
     skip_curriculum: bool,
@@ -154,24 +159,28 @@ fn main() -> Result<(), anyhow::Error> {
                     .set(Arc::new(RwLock::new(HashMap::new())))
                     .unwrap();
             }
+            let mut urls = Vec::new();
+            let mut docs = Vec::new();
             println!("Building everything 🛠️");
-            let start = std::time::Instant::now();
-            let docs = if !args.files.is_empty() {
-                read_docs_parallel::<Doc>(&args.files, None)?
-            } else if !args.cache_content {
-                let files: &[_] = if let Some(translated_root) = content_translated_root() {
-                    &[content_root(), translated_root]
+            if !args.skip_content {
+                let start = std::time::Instant::now();
+                docs = if !args.files.is_empty() {
+                    read_docs_parallel::<Doc>(&args.files, None)?
+                } else if !args.cache_content {
+                    let files: &[_] = if let Some(translated_root) = content_translated_root() {
+                        &[content_root(), translated_root]
+                    } else {
+                        &[content_root()]
+                    };
+                    read_docs_parallel::<Doc>(files, None)?
                 } else {
-                    &[content_root()]
+                    read_and_cache_doc_pages()?
                 };
-                read_docs_parallel::<Doc>(files, None)?
-            } else {
-                read_and_cache_doc_pages()?
-            };
-            println!("Took: {: >10.3?} for {}", start.elapsed(), docs.len());
-            let mut urls = Vec::new();
+                println!("Took: {: >10.3?} for {}", start.elapsed(), docs.len());
+            }
             if !args.skip_spas {
                 let start = std::time::Instant::now();
+                urls.extend(build_spas()?);
                 urls.extend(build_generic_pages()?);
                 println!("Took: {: >10.3?} to build spas", start.elapsed());
             }
@@ -190,6 +199,14 @@ fn main() -> Result<(), anyhow::Error> {
                 urls.extend(build_blog_pages()?);
                 println!("Took: {: >10.3?} to build blog", start.elapsed());
             }
+            if !args.skip_contributors && args.files.is_empty() {
+                let start = std::time::Instant::now();
+                urls.extend(build_contributor_spotlight_pages()?);
+                println!(
+                    "Took: {: >10.3?} to build contributor spotlight",
+                    start.elapsed()
+                );
+            }
             if !args.skip_sitemap && args.files.is_empty() && !urls.is_empty() {
                 let start = std::time::Instant::now();
                 let out_path = build_out_root()?;

src/serve.rs

@@ -10,6 +10,7 @@ use tiny_http::{Response, Server};
 use tracing::{error, span, Level};
 
 fn get_json(url: &str) -> Result<BuiltDocy, Error> {
+    let url = url.strip_suffix("index.json").unwrap_or(url);
     let page = Page::page_from_url_path(url)?;
 
     let slug = &page.slug();