feat: support size option for moduleIds and chunkIds of optimization …

…config

crates/node_binding/binding.d.ts

@@ -272,9 +272,11 @@ export enum BuiltinPluginName {
   NamedModuleIdsPlugin = 'NamedModuleIdsPlugin',
   NaturalModuleIdsPlugin = 'NaturalModuleIdsPlugin',
   DeterministicModuleIdsPlugin = 'DeterministicModuleIdsPlugin',
+  OccurrenceModuleIdsPlugin = 'OccurrenceModuleIdsPlugin',
   NaturalChunkIdsPlugin = 'NaturalChunkIdsPlugin',
   NamedChunkIdsPlugin = 'NamedChunkIdsPlugin',
   DeterministicChunkIdsPlugin = 'DeterministicChunkIdsPlugin',
+  OccurrenceChunkIdsPlugin = 'OccurrenceChunkIdsPlugin',
   RealContentHashPlugin = 'RealContentHashPlugin',
   RemoveEmptyChunksPlugin = 'RemoveEmptyChunksPlugin',
   EnsureChunkConditionsPlugin = 'EnsureChunkConditionsPlugin',
@@ -1611,6 +1613,14 @@ export interface RawNonStandard {
   deepSelectorCombinator: boolean
 }
 
+export interface RawOccurrenceChunkIdsPluginOptions {
+  prioritiseInitial?: boolean
+}
+
+export interface RawOccurrenceModuleIdsPluginOptions {
+  prioritiseInitial?: boolean
+}
+
 export interface RawOptimizationOptions {
   removeAvailableModules: boolean
   sideEffects: string

crates/rspack_binding_options/src/options/raw_builtins/mod.rs

@@ -3,6 +3,7 @@ mod raw_bundle_info;
 mod raw_copy;
 mod raw_css_extract;
 mod raw_html;
+mod raw_ids;
 mod raw_ignore;
 mod raw_lazy_compilation;
 mod raw_lightning_css_minimizer;
@@ -15,13 +16,15 @@ mod raw_swc_js_minimizer;
 
 use napi::{bindgen_prelude::FromNapiValue, Env, JsUnknown};
 use napi_derive::napi;
+use raw_ids::{RawOccurrenceChunkIdsPluginOptions, RawOccurrenceModuleIdsPluginOptions};
 use raw_lightning_css_minimizer::RawLightningCssMinimizerRspackPluginOptions;
 use rspack_binding_values::entry::JsEntryPluginOptions;
 use rspack_core::{BoxPlugin, Plugin, PluginExt};
 use rspack_error::Result;
 use rspack_ids::{
   DeterministicChunkIdsPlugin, DeterministicModuleIdsPlugin, NamedChunkIdsPlugin,
-  NamedModuleIdsPlugin, NaturalChunkIdsPlugin, NaturalModuleIdsPlugin,
+  NamedModuleIdsPlugin, NaturalChunkIdsPlugin, NaturalModuleIdsPlugin, OccurrenceChunkIdsPlugin,
+  OccurrenceModuleIdsPlugin,
 };
 use rspack_napi::NapiResultExt;
 use rspack_plugin_asset::AssetPlugin;
@@ -135,9 +138,11 @@ pub enum BuiltinPluginName {
   NamedModuleIdsPlugin,
   NaturalModuleIdsPlugin,
   DeterministicModuleIdsPlugin,
+  OccurrenceModuleIdsPlugin,
   NaturalChunkIdsPlugin,
   NamedChunkIdsPlugin,
   DeterministicChunkIdsPlugin,
+  OccurrenceChunkIdsPlugin,
   RealContentHashPlugin,
   RemoveEmptyChunksPlugin,
   EnsureChunkConditionsPlugin,
@@ -343,6 +348,12 @@ impl BuiltinPlugin {
       BuiltinPluginName::DeterministicModuleIdsPlugin => {
         plugins.push(DeterministicModuleIdsPlugin::default().boxed())
       }
+      BuiltinPluginName::OccurrenceModuleIdsPlugin => plugins.push(
+        OccurrenceModuleIdsPlugin::new(
+          downcast_into::<RawOccurrenceModuleIdsPluginOptions>(self.options)?.into(),
+        )
+        .boxed(),
+      ),
       BuiltinPluginName::NaturalChunkIdsPlugin => {
         plugins.push(NaturalChunkIdsPlugin::default().boxed())
       }
@@ -352,6 +363,12 @@ impl BuiltinPlugin {
       BuiltinPluginName::DeterministicChunkIdsPlugin => {
         plugins.push(DeterministicChunkIdsPlugin::default().boxed())
       }
+      BuiltinPluginName::OccurrenceChunkIdsPlugin => plugins.push(
+        OccurrenceChunkIdsPlugin::new(
+          downcast_into::<RawOccurrenceChunkIdsPluginOptions>(self.options)?.into(),
+        )
+        .boxed(),
+      ),
       BuiltinPluginName::RealContentHashPlugin => {
         plugins.push(RealContentHashPlugin::default().boxed())
       }

crates/rspack_binding_options/src/options/raw_builtins/raw_ids.rs

@@ -0,0 +1,30 @@
+use napi_derive::napi;
+use rspack_ids::{OccurrenceChunkIdsPluginOptions, OccurrenceModuleIdsPluginOptions};
+
+#[derive(Debug)]
+#[napi(object, object_to_js = false)]
+pub struct RawOccurrenceChunkIdsPluginOptions {
+  pub prioritise_initial: Option<bool>,
+}
+
+impl From<RawOccurrenceChunkIdsPluginOptions> for OccurrenceChunkIdsPluginOptions {
+  fn from(value: RawOccurrenceChunkIdsPluginOptions) -> Self {
+    Self {
+      prioritise_initial: value.prioritise_initial.unwrap_or_default(),
+    }
+  }
+}
+
+#[derive(Debug)]
+#[napi(object, object_to_js = false)]
+pub struct RawOccurrenceModuleIdsPluginOptions {
+  pub prioritise_initial: Option<bool>,
+}
+
+impl From<RawOccurrenceModuleIdsPluginOptions> for OccurrenceModuleIdsPluginOptions {
+  fn from(value: RawOccurrenceModuleIdsPluginOptions) -> Self {
+    Self {
+      prioritise_initial: value.prioritise_initial.unwrap_or_default(),
+    }
+  }
+}

crates/rspack_core/src/chunk.rs

@@ -411,6 +411,10 @@ impl Chunk {
     self.groups.contains(chunk_group)
   }
 
+  pub fn get_number_of_groups(&self) -> usize {
+    self.groups.len()
+  }
+
   pub fn disconnect_from_groups(&mut self, chunk_group_by_ukey: &mut ChunkGroupByUkey) {
     for group_ukey in self.groups.iter() {
       let group = chunk_group_by_ukey.expect_get_mut(group_ukey);

crates/rspack_core/src/chunk_graph/chunk_graph_module.rs

@@ -42,6 +42,17 @@ impl ChunkGraph {
       .or_default();
   }
 
+  pub fn is_entry_module_in_chunk(
+    &self,
+    module_identifier: &ModuleIdentifier,
+    chunk_ukey: ChunkUkey,
+  ) -> bool {
+    let chunk_graph_chunk = self.get_chunk_graph_chunk(&chunk_ukey);
+    chunk_graph_chunk
+      .entry_modules
+      .contains_key(module_identifier)
+  }
+
   pub fn is_module_in_chunk(
     &self,
     module_identifier: &ModuleIdentifier,

crates/rspack_core/src/dependency/dependency_trait.rs

@@ -109,6 +109,10 @@ pub trait Dependency:
   }
 
   fn could_affect_referencing_module(&self) -> AffectType;
+
+  fn get_number_of_id_occurrences(&self) -> usize {
+    1
+  }
 }
 
 impl dyn Dependency + '_ {

crates/rspack_ids/src/lib.rs

@@ -12,3 +12,7 @@ mod natural_module_ids_plugin;
 pub use natural_module_ids_plugin::NaturalModuleIdsPlugin;
 mod natural_chunk_ids_plugin;
 pub use natural_chunk_ids_plugin::NaturalChunkIdsPlugin;
+mod occurrence_module_ids_plugin;
+pub use occurrence_module_ids_plugin::*;
+mod occurrence_chunk_ids_plugin;
+pub use occurrence_chunk_ids_plugin::*;

crates/rspack_ids/src/occurrence_chunk_ids_plugin.rs

@@ -0,0 +1,94 @@
+use std::collections::HashMap;
+
+use itertools::Itertools;
+use rspack_core::{
+  get_chunk_group_from_ukey, ApplyContext, Chunk, CompilationChunkIds, CompilerOptions, Plugin,
+  PluginContext,
+};
+use rspack_error::Result;
+use rspack_hook::{plugin, plugin_hook};
+
+use crate::id_helpers::{assign_ascending_chunk_ids, compare_chunks_natural};
+
+pub struct OccurrenceChunkIdsPluginOptions {
+  pub prioritise_initial: bool,
+}
+
+#[plugin]
+#[derive(Debug, Default)]
+pub struct OccurrenceChunkIdsPlugin {
+  prioritise_initial: bool,
+}
+
+impl OccurrenceChunkIdsPlugin {
+  pub fn new(option: OccurrenceChunkIdsPluginOptions) -> Self {
+    Self::new_inner(option.prioritise_initial)
+  }
+}
+
+#[plugin_hook(CompilationChunkIds for OccurrenceChunkIdsPlugin)]
+fn chunk_ids(&self, compilation: &mut rspack_core::Compilation) -> Result<()> {
+  let chunk_graph = &compilation.chunk_graph;
+  let module_graph = &compilation.get_module_graph();
+  let chunk_group_by_ukey = &compilation.chunk_group_by_ukey;
+  let mut occurs_in_initial_chunks_map = HashMap::new();
+
+  for chunk in compilation.chunk_by_ukey.values() {
+    let mut occurs = 0;
+    for chunk_group_ukey in &chunk.groups {
+      if let Some(chunk_group) = get_chunk_group_from_ukey(chunk_group_ukey, chunk_group_by_ukey) {
+        for parent_ukey in &chunk_group.parents {
+          if let Some(parent) = get_chunk_group_from_ukey(parent_ukey, chunk_group_by_ukey) {
+            if parent.is_initial() {
+              occurs += 1;
+            }
+          }
+        }
+      }
+    }
+    occurs_in_initial_chunks_map.insert(chunk.ukey, occurs);
+  }
+
+  let chunks = compilation
+    .chunk_by_ukey
+    .values()
+    .map(|chunk| chunk as &Chunk)
+    .sorted_unstable_by(|a, b| {
+      if self.prioritise_initial {
+        let a_entry_occurs = occurs_in_initial_chunks_map.get(&a.ukey).unwrap_or(&0);
+        let b_entry_occurs = occurs_in_initial_chunks_map.get(&b.ukey).unwrap_or(&0);
+        if a_entry_occurs != b_entry_occurs {
+          return b_entry_occurs.cmp(a_entry_occurs);
+        }
+      }
+
+      let a_occurs = a.get_number_of_groups();
+      let b_occurs = b.get_number_of_groups();
+      if a_occurs != b_occurs {
+        return b_occurs.cmp(&a_occurs);
+      }
+
+      compare_chunks_natural(chunk_graph, module_graph, a, b)
+    })
+    .map(|chunk| chunk.ukey)
+    .collect::<Vec<_>>();
+
+  assign_ascending_chunk_ids(&chunks, compilation);
+
+  Ok(())
+}
+
+impl Plugin for OccurrenceChunkIdsPlugin {
+  fn name(&self) -> &'static str {
+    "OccurrenceChunkIdsPlugin"
+  }
+
+  fn apply(&self, ctx: PluginContext<&mut ApplyContext>, _options: &CompilerOptions) -> Result<()> {
+    ctx
+      .context
+      .compilation_hooks
+      .chunk_ids
+      .tap(chunk_ids::new(self));
+    Ok(())
+  }
+}