feat: 完成尾部数据的优化操作

Author: KonghaYao

src/lib.rs

@@ -35,12 +35,12 @@ fn main_test() {
                 // polyfill: vec![],
                 // comment_base: Some(true),
                 // comment_name_table: Some(true),
-                // comment_unicodes: Some(true),
+                comment_unicodes: Some(true),
                 // compress: Some(true),
                 // file_name: Some("input.css".to_string()),
                 ..Default::default()
             }),
-            chunk_size: Some(20 * 1024),
+            // chunk_size: Some(40 * 1024),
             // 精确控制
             // subsets: vec![[65]].iter().map(|x| u32_array_to_u8_array(x)).collect(),
             // language_areas: Some(false),

src/pre_subset/mod.rs

@@ -76,7 +76,7 @@ pub fn pre_subset(ctx: &mut Context) {
     if ctx.input.font_feature.unwrap_or(true) {
         process.push(features_plugin);
     }
-    if ctx.input.reduce_mins.unwrap_or(true) {
+    if ctx.input.reduce_mins.unwrap_or(false) {
         process.push(reduce_min_plugin);
     }
     for p in process {

src/pre_subset/plugin_auto_subset.rs

@@ -1,6 +1,6 @@
 use indexmap::IndexSet;
 
-use log::info;
+use log::{debug, info};
 
 use crate::run_subset::build_single_subset;
 
@@ -36,31 +36,74 @@ pub fn chunk_iterable_and_flat(
     subsets: &mut Vec<IndexSet<u32>>,
     max_chunk_size: u32,
 ) -> Vec<IndexSet<u32>> {
-    let max_chunk_size = max_chunk_size - 1;
     subsets
         .iter()
-        .flat_map(|subset| {
-            let mut count = 0;
-            let mut result: Vec<IndexSet<u32>> = vec![];
-            let mut new_subset: IndexSet<u32> = IndexSet::new();
-            subset.iter().for_each(|c| {
-                new_subset.insert(c.clone());
-                if count >= max_chunk_size {
-                    count = 0;
-                    result.push(new_subset.clone());
-                    new_subset = IndexSet::new();
-                } else {
-                    count += 1;
-                }
-            });
-            if new_subset.len() > 0 {
-                result.push(new_subset)
-            };
-            result
-        })
+        .flat_map(|subset| split_vector(subset, max_chunk_size))
         .collect::<Vec<IndexSet<u32>>>()
 }
 
+// 计算当前包需要容纳多少个字符 y= max_count/ x^(1/3)
+fn length_for_index(x: usize, max_count: u32) -> usize {
+    let y: f32 = (max_count as f32) / (x as f32).cbrt(); // 计算立方根并求解y
+    let y_ceil = y.ceil(); // 将结果向上取整
+    y_ceil as usize
+}
+fn split_vector(vec: &IndexSet<u32>, max_count: u32) -> Vec<IndexSet<u32>> {
+    let mut result: Vec<IndexSet<u32>> = Vec::new();
+    let mut current_start = 0;
+    let size = vec.len();
+
+    for i in 1.. {
+        if current_start >= size {
+            debug!("fold {} -> {} | max {}", size, i - 1, max_count);
+            break;
+        }
+        let len = length_for_index(i, max_count);
+        // println!("{}", len);
+        let to_take = std::cmp::min(len, size - current_start);
+        let new_sub_vec = IndexSet::from_iter(
+            vec[current_start..current_start + to_take].iter().cloned(),
+        );
+        result.push(new_sub_vec);
+        current_start += to_take;
+    }
+
+    result
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn split_vector_empty_input_empty_result() {
+        let input = IndexSet::new();
+        let result = split_vector(&input, 150);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn split_vector_single_element_single_element_result() {
+        let mut input = IndexSet::new();
+        for x in 1..10 {
+            input.insert(x);
+        }
+        let result = split_vector(&input, 150);
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0], input);
+        // println!("result: {:?}", result)
+    }
+
+    #[test]
+    fn split_vector_multiple_elements_multiple_subsets() {
+        let mut input = IndexSet::new();
+        for x in 1..400 {
+            input.insert(x);
+        }
+        let result = split_vector(&input, 150);
+        println!("result: {:#?}", result);
+        assert_eq!(result.len(), 4);
+    }
+}
 #[test]
 fn for_chunk_iterable_and_flat() {
     let mut subsets = vec![
@@ -71,11 +114,12 @@ fn for_chunk_iterable_and_flat() {
     assert_eq!(
         result,
         vec![
-            IndexSet::from([1, 2, 3, 4, 5]),
-            IndexSet::from([6, 7, 8, 9, 10]),
-            IndexSet::from([11, 12, 13, 14, 15]),
-            IndexSet::from([16, 17, 18, 19, 20]),
-            IndexSet::from([21]),
+            IndexSet::from([1, 2, 3, 4]),
+            IndexSet::from([5, 6, 7, 8]),
+            IndexSet::from([9, 10]),
+            IndexSet::from([11, 12, 13, 14]),
+            IndexSet::from([15, 16, 17, 18]),
+            IndexSet::from([19, 20, 21]),
         ]
     );
 }

src/run_subset.rs

@@ -13,7 +13,6 @@ use log::{debug, warn};
 use rayon::iter::{
     IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator,
 };
-use std::collections::btree_set::Difference;
 use std::time::Instant;
 use woff::version2::compress;