Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

8.43 kB

use anyhow::Result;
use next_core::{
    next_client_reference::{CssClientReferenceModule, EcmascriptClientReferenceModule},
    next_server_component::server_component_module::NextServerComponentModule,
};
use roaring::RoaringBitmap;
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
use turbo_tasks::{
    FxIndexSet, NonLocalValue, ResolvedVc, TryFlatJoinIterExt, Vc, debug::ValueDebugFormat,
    trace::TraceRawVcs,
};
use turbopack::css::chunk::CssChunkPlaceable;
use turbopack_core::{
    module::Module,
    module_graph::{
        GraphTraversalAction, SingleModuleGraph, SingleModuleGraphModuleNode,
        chunk_group_info::RoaringBitmapWrapper,
    },
};

#[derive(
    Copy, Clone, Serialize, Deserialize, Eq, PartialEq, TraceRawVcs, ValueDebugFormat, NonLocalValue,
)]
pub enum ClientManifestEntryType {
    EcmascriptClientReference {
        module: ResolvedVc<EcmascriptClientReferenceModule>,
        ssr_module: ResolvedVc<Box<dyn Module>>,
    },
    CssClientReference(ResolvedVc<Box<dyn CssChunkPlaceable>>),
    ServerComponent(ResolvedVc<NextServerComponentModule>),
}

/// Tracks information about all the css and js client references in the graph as well as how server
/// components depend on them.
#[turbo_tasks::value]
pub struct ClientReferenceManifest {
    pub manifest: FxHashMap<ResolvedVc<Box<dyn Module>>, ClientManifestEntryType>,
    // All the server components in the graph.
    server_components: FxIndexSet<ResolvedVc<NextServerComponentModule>>,
    // All the server components that depend on each module
    // This only includes mappings for modules with client references and the bitmaps reference
    // indices into `[server_components]`
    server_components_for_client_references:
        FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>,
}

impl ClientReferenceManifest {
    /// Returns all the server components that depend on the given client reference
    pub fn server_components_for_client_reference(
        &self,
        module: ResolvedVc<Box<dyn Module>>,
    ) -> impl Iterator<Item = ResolvedVc<NextServerComponentModule>> {
        let bitmap = &self
            .server_components_for_client_references
            .get(&module)
            .expect("Module should be a client reference module")
            .0;

        bitmap
            .iter()
            .map(|index| *self.server_components.get_index(index as usize).unwrap())
    }
}

#[turbo_tasks::function]
pub async fn map_client_references(
    graph: Vc<SingleModuleGraph>,
) -> Result<Vc<ClientReferenceManifest>> {
    let graph = graph.await?;
    let manifest = graph
        .iter_nodes()
        .map(|node| async move {
            let module = node.module;

            if let Some(client_reference_module) =
                ResolvedVc::try_downcast_type::<EcmascriptClientReferenceModule>(module)
            {
                Ok(Some((
                    module,
                    ClientManifestEntryType::EcmascriptClientReference {
                        module: client_reference_module,
                        ssr_module: ResolvedVc::upcast(client_reference_module.await?.ssr_module),
                    },
                )))
            } else if let Some(client_reference_module) =
                ResolvedVc::try_downcast_type::<CssClientReferenceModule>(module)
            {
                Ok(Some((
                    module,
                    ClientManifestEntryType::CssClientReference(
                        client_reference_module.await?.client_module,
                    ),
                )))
            } else if let Some(server_component) =
                ResolvedVc::try_downcast_type::<NextServerComponentModule>(module)
            {
                Ok(Some((
                    module,
                    ClientManifestEntryType::ServerComponent(server_component),
                )))
            } else {
                Ok(None)
            }
        })
        .try_flat_join()
        .await?
        .into_iter()
        .collect::<FxHashMap<_, _>>();

    let mut server_components = FxIndexSet::default();
    let mut module_to_server_component_bits = FxHashMap::default();
    if !manifest.is_empty() {
        graph.traverse_edges_from_entries_fixed_point(
            graph.entry_modules(),
            |parent_info, node| {
                let module = node.module();
                let module_type = manifest.get(&module);
                let mut should_visit_children = match module_to_server_component_bits.entry(module)
                {
                    std::collections::hash_map::Entry::Occupied(_) => false,
                    std::collections::hash_map::Entry::Vacant(vacant_entry) => {
                        // only do this the first time we visit the node.
                        let bits = vacant_entry.insert(RoaringBitmap::new());
                        if let Some(ClientManifestEntryType::ServerComponent(
                            server_component_module,
                        )) = module_type
                        {
                            let index = server_components.insert_full(*server_component_module).0;

                            bits.insert(index.try_into().unwrap());
                        }
                        true
                    }
                };
                if let Some((SingleModuleGraphModuleNode{module: parent_module}, _)) = parent_info
                    // Skip self cycles such as in
                    // test/e2e/app-dir/dynamic-import/app/page.tsx where a very-dynamic import induces a
                    // self cycle. They don't introduce new bits anyway.
                    && module != *parent_module
                {
                    // Copy parent bits down.  `traverse_edges_from_entries_fixed_point` always
                    // visits parents before children so we can simply assert
                    // that the parent it set.
                    let [Some(current), Some(parent)] =
                        module_to_server_component_bits.get_disjoint_mut([&module, parent_module])
                    else {
                        unreachable!()
                    };
                    // Check if we are adding new bits and thus need to revisit children unless we
                    // are already planning to because this is a new node.
                    if !should_visit_children {
                        let len = current.len();
                        *current |= &*parent;
                        // did we find new bits? If so visit the children again
                        should_visit_children = len != current.len();
                    } else {
                        *current |= &*parent;
                    }
                }

                Ok(match module_type {
                    Some(
                        ClientManifestEntryType::EcmascriptClientReference { .. }
                        | ClientManifestEntryType::CssClientReference { .. },
                    ) => {
                        // No need to explore these subgraphs ever, these are the leaves in the
                        // server component graph
                        GraphTraversalAction::Skip
                    }
                    // Continue on server components and through graphs of non-ClientReference
                    // modules, but only if our set of parent components has changed.
                    _ => {
                        if should_visit_children {
                            GraphTraversalAction::Continue
                        } else {
                            GraphTraversalAction::Skip
                        }
                    }
                })
            },
        )?;
    }

    // Filter down to just the client reference modules to reduce datastructure size
    let server_components_for_client_references = module_to_server_component_bits
        .into_iter()
        .filter_map(|(k, v)| match manifest.get(&k) {
            Some(
                ClientManifestEntryType::CssClientReference(_)
                | ClientManifestEntryType::EcmascriptClientReference { .. },
            ) => Some((k, RoaringBitmapWrapper(v))),
            _ => None,
        })
        .collect();

    Ok(ClientReferenceManifest::cell(ClientReferenceManifest {
        manifest,
        server_components,
        server_components_for_client_references,
    }))
}

	use anyhow::Result;
	use next_core::{
	next_client_reference::{CssClientReferenceModule, EcmascriptClientReferenceModule},
	next_server_component::server_component_module::NextServerComponentModule,
	};
	use roaring::RoaringBitmap;
	use rustc_hash::FxHashMap;
	use serde::{Deserialize, Serialize};
	use turbo_tasks::{
	FxIndexSet, NonLocalValue, ResolvedVc, TryFlatJoinIterExt, Vc, debug::ValueDebugFormat,
	trace::TraceRawVcs,
	};
	use turbopack::css::chunk::CssChunkPlaceable;
	use turbopack_core::{
	module::Module,
	module_graph::{
	GraphTraversalAction, SingleModuleGraph, SingleModuleGraphModuleNode,
	chunk_group_info::RoaringBitmapWrapper,
	},
	};

	#[derive(
	Copy, Clone, Serialize, Deserialize, Eq, PartialEq, TraceRawVcs, ValueDebugFormat, NonLocalValue,
	)]
	pub enum ClientManifestEntryType {
	EcmascriptClientReference {
	module: ResolvedVc<EcmascriptClientReferenceModule>,
	ssr_module: ResolvedVc<Box<dyn Module>>,
	},
	CssClientReference(ResolvedVc<Box<dyn CssChunkPlaceable>>),
	ServerComponent(ResolvedVc<NextServerComponentModule>),
	}

	/// Tracks information about all the css and js client references in the graph as well as how server
	/// components depend on them.
	#[turbo_tasks::value]
	pub struct ClientReferenceManifest {
	pub manifest: FxHashMap<ResolvedVc<Box<dyn Module>>, ClientManifestEntryType>,
	// All the server components in the graph.
	server_components: FxIndexSet<ResolvedVc<NextServerComponentModule>>,
	// All the server components that depend on each module
	// This only includes mappings for modules with client references and the bitmaps reference
	// indices into `[server_components]`
	server_components_for_client_references:
	FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>,
	}

	impl ClientReferenceManifest {
	/// Returns all the server components that depend on the given client reference
	pub fn server_components_for_client_reference(
	&self,
	module: ResolvedVc<Box<dyn Module>>,
	) -> impl Iterator<Item = ResolvedVc<NextServerComponentModule>> {
	let bitmap = &self
	.server_components_for_client_references
	.get(&module)
	.expect("Module should be a client reference module")
	.0;

	bitmap
	.iter()
	.map(\|index\| *self.server_components.get_index(index as usize).unwrap())
	}
	}

	#[turbo_tasks::function]
	pub async fn map_client_references(
	graph: Vc<SingleModuleGraph>,
	) -> Result<Vc<ClientReferenceManifest>> {
	let graph = graph.await?;
	let manifest = graph
	.iter_nodes()
	.map(\|node\| async move {
	let module = node.module;

	if let Some(client_reference_module) =
	ResolvedVc::try_downcast_type::<EcmascriptClientReferenceModule>(module)
	{
	Ok(Some((
	module,
	ClientManifestEntryType::EcmascriptClientReference {
	module: client_reference_module,
	ssr_module: ResolvedVc::upcast(client_reference_module.await?.ssr_module),
	},
	)))
	} else if let Some(client_reference_module) =
	ResolvedVc::try_downcast_type::<CssClientReferenceModule>(module)
	{
	Ok(Some((
	module,
	ClientManifestEntryType::CssClientReference(
	client_reference_module.await?.client_module,
	),
	)))
	} else if let Some(server_component) =
	ResolvedVc::try_downcast_type::<NextServerComponentModule>(module)
	{
	Ok(Some((
	module,
	ClientManifestEntryType::ServerComponent(server_component),
	)))
	} else {
	Ok(None)
	}
	})
	.try_flat_join()
	.await?
	.into_iter()
	.collect::<FxHashMap<_, _>>();

	let mut server_components = FxIndexSet::default();
	let mut module_to_server_component_bits = FxHashMap::default();
	if !manifest.is_empty() {
	graph.traverse_edges_from_entries_fixed_point(
	graph.entry_modules(),
	\|parent_info, node\| {
	let module = node.module();
	let module_type = manifest.get(&module);
	let mut should_visit_children = match module_to_server_component_bits.entry(module)
	{
	std::collections::hash_map::Entry::Occupied(_) => false,
	std::collections::hash_map::Entry::Vacant(vacant_entry) => {
	// only do this the first time we visit the node.
	let bits = vacant_entry.insert(RoaringBitmap::new());
	if let Some(ClientManifestEntryType::ServerComponent(
	server_component_module,
	)) = module_type
	{
	let index = server_components.insert_full(*server_component_module).0;

	bits.insert(index.try_into().unwrap());
	}
	true
	}
	};
	if let Some((SingleModuleGraphModuleNode{module: parent_module}, _)) = parent_info
	// Skip self cycles such as in
	// test/e2e/app-dir/dynamic-import/app/page.tsx where a very-dynamic import induces a
	// self cycle. They don't introduce new bits anyway.
	&& module != *parent_module
	{
	// Copy parent bits down. `traverse_edges_from_entries_fixed_point` always
	// visits parents before children so we can simply assert
	// that the parent it set.
	let [Some(current), Some(parent)] =
	module_to_server_component_bits.get_disjoint_mut([&module, parent_module])
	else {
	unreachable!()
	};
	// Check if we are adding new bits and thus need to revisit children unless we
	// are already planning to because this is a new node.
	if !should_visit_children {
	let len = current.len();
	current \|= &parent;
	// did we find new bits? If so visit the children again
	should_visit_children = len != current.len();
	} else {
	current \|= &parent;
	}
	}

	Ok(match module_type {
	Some(
	ClientManifestEntryType::EcmascriptClientReference { .. }
	\| ClientManifestEntryType::CssClientReference { .. },
	) => {
	// No need to explore these subgraphs ever, these are the leaves in the
	// server component graph
	GraphTraversalAction::Skip
	}
	// Continue on server components and through graphs of non-ClientReference
	// modules, but only if our set of parent components has changed.
	_ => {
	if should_visit_children {
	GraphTraversalAction::Continue
	} else {
	GraphTraversalAction::Skip
	}
	}
	})
	},
	)?;
	}

	// Filter down to just the client reference modules to reduce datastructure size
	let server_components_for_client_references = module_to_server_component_bits
	.into_iter()
	.filter_map(\|(k, v)\| match manifest.get(&k) {
	Some(
	ClientManifestEntryType::CssClientReference(_)
	\| ClientManifestEntryType::EcmascriptClientReference { .. },
	) => Some((k, RoaringBitmapWrapper(v))),
	_ => None,
	})
	.collect();

	Ok(ClientReferenceManifest::cell(ClientReferenceManifest {
	manifest,
	server_components,
	server_components_for_client_references,
	}))
	}