Struct ModuleGraph 

pub struct ModuleGraph { /* private fields */ }

Implementations

impl ModuleGraph

pub fn new() -> Self

pub fn ensure_module(&mut self, path: &Path) -> &mut ModuleNode

pub fn add_import(&mut self, importer: &Path, imported: &Path)

pub fn set_self_accepting(&mut self, path: &Path, accepting: bool)

pub fn set_accepted_deps(&mut self, path: &Path, deps: &[PathBuf])

pub fn update_targets( &self, changed: &Path, ) -> Result<Vec<UpdateTarget>, String>

The update targets for a change. A self-accepting boundary accepts itself; an importer that declared the changed module (or a module on the way up) in hot.accept(deps) is the boundary for that dependency. Err means a full reload.

pub fn update_targets_from_importers( &self, changed: &Path, ) -> Result<Vec<UpdateTarget>, String>

The update targets when a module calls import.meta.hot.invalidate(): its own acceptance is skipped and the walk starts at its importers, as Vite’s updateModules(..., [...mod.importers]) does. A module nothing imports is an entry, so the page must reload.

pub fn set_imports( &mut self, importer: &Path, imports: &[PathBuf], ) -> Vec<PathBuf>

Record a module’s imports, returning the dependencies it no longer imports that nothing else imports either (Vite’s prunedImports in updateModuleInfo): the client is told to prune them so their side effects (an injected stylesheet) are undone.

pub fn stamp_pruned(&mut self, paths: &[PathBuf], timestamp: u64)

Stamp pruned modules so a later re-import fetches and re-runs them (their side effects were undone), as Vite’s handlePrunedModules.

pub fn accept_invalidation( &mut self, changed: &Path, timestamp: u64, ) -> Option<Vec<PathBuf>>

Accept a client’s import.meta.hot.invalidate() for changed: only a self-accepting module an update already touched, and only once per update (Vite’s lastHMRInvalidationReceived). Its importers up to the next boundaries are stamped so their re-fetch sees the invalidated module’s current version; the module itself keeps its stamp, so the instance the browser already loaded is reused rather than re-evaluated. Returns the stamped importers, or None when the call is ignored.

pub fn contains(&self, path: &Path) -> bool

pub fn module_paths(&self) -> Vec<PathBuf>

pub fn propagate_update(&self, changed: &Path) -> HmrDecision

pub fn node(&self, path: &Path) -> Option<&ModuleNode>

pub fn stamp_update(&mut self, changed: &Path, timestamp: u64) -> Vec<PathBuf>

Record an HMR update of changed: stamp it and every module it dirties (its importers up to and including the accepting boundaries) with timestamp, and return that dirty set. Mirrors Vite’s moduleGraph.invalidateModule walking importers.

pub fn hmr_timestamp(&self, path: &Path) -> u64

pub fn imports_timestamp(&self, path: &Path) -> u64

The newest HMR timestamp among a module’s direct imports: part of the module’s compile cache key, so a cached importer is recompiled (and its import specifiers re-stamped) after one of its imports updates.

pub fn propagate_from_seeds(&self, seeds: &[&Path]) -> HmrDecision

pub fn update_plan(&self, changed: &Path) -> Result<UpdatePlan, String>

pub fn update_plan_from_importers( &self, changed: &Path, ) -> Result<UpdatePlan, String>

pub fn propagate_update_from_importers(&self, changed: &Path) -> HmrDecision

Trait Implementations

impl Debug for ModuleGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ModuleGraph

fn default() -> ModuleGraph

Returns the “default value” for a type.