Fonts: shape long items in bounded pieces

The shaper lets one call grow to 256 glyphs per input character, as an
embedded font's substitutions decide, and every glyph was then copied out.
Items longer than 1 KiB are now shaped in pieces (cut at a space where one
is near, never before a combining mark or after a joiner), each with the
rest of the paragraph as context and the item's script, and a piece that
expands past 32 glyphs per character falls back to one glyph per character
from the cmap.

crates/anim/src/morph.rs

@@ -1,7 +1,5 @@
 //! Morph: matching shapes between two slides, interpolating their boxes and building the frames.
 
-use std::collections::{HashMap, HashSet, VecDeque};
-
 use deckcraft_model::resolve::{self, Ctx};
 use deckcraft_model::{ColorRef, Fill, Geom, Presentation, Rgba, Shape, ShapeId, ShapeKind, Slide, Xfrm, walk};
 
@@ -17,66 +15,48 @@ fn text_of(s: &Shape) -> String {
 /// kind and preset geometry if neither carries text. A text box with neither a name nor its text on
 /// the other slide stays unpaired and fades in place, as in PowerPoint (#119). Each shape is used
 /// once; top-level shapes only (groups move whole).
-///
-/// Each pass compares a key of the two shapes, so the shapes of `b` are indexed by key once per
-/// pass: matching costs the sum of the two shape lists, not their product.
 pub fn morph_pairs(a: &Slide, b: &Slide) -> Vec<(ShapeId, ShapeId)> {
     let mut pairs: Vec<(ShapeId, ShapeId)> = Vec::new();
     let mut used_a = vec![false; a.shapes.len()];
     let mut used_b = vec![false; b.shapes.len()];
-    // Each shape's text, worked out once rather than inside every comparison.
-    let text_a: Vec<String> = a.shapes.iter().map(text_of).collect();
-    let text_b: Vec<String> = b.shapes.iter().map(text_of).collect();
-    let forced = |s: &Shape, _: &str| (s.name.starts_with("!!")).then(|| MorphKey::Name(s.name.clone()));
-    let named = |s: &Shape, _: &str| (!s.name.is_empty()).then(|| MorphKey::Name(s.name.clone()));
-    let same_text = |s: &Shape, t: &str| (!t.trim().is_empty()).then(|| MorphKey::Text(s.kind_name(), t.to_string()));
-    let same_geom = |s: &Shape, t: &str| match s.geom.preset_name() {
-        Some(g) if t.trim().is_empty() => Some(MorphKey::Geom(s.kind_name(), g.to_string())),
-        _ => None,
-    };
-    let passes: [&dyn Fn(&Shape, &str) -> Option<MorphKey>; 4] = [&forced, &named, &same_text, &same_geom];
-    for key in passes {
-        // Unused shapes of `b` by key, in slide order: the front of each queue is the first unused
-        // match, which is the one a search through `b` would find.
-        let mut index: HashMap<MorphKey, VecDeque<usize>> = HashMap::new();
-        for (j, sb) in b.shapes.iter().enumerate() {
-            if used_b.get(j).copied().unwrap_or(true) {
-                continue;
+    let passes: [&dyn Fn(&Shape, &Shape) -> bool; 4] = [
+        &|x, y| x.name.starts_with("!!") && x.name == y.name,
+        &|x, y| !x.name.is_empty() && x.name == y.name,
+        &|x, y| {
+            if x.kind_name() != y.kind_name() {
+                return false;
             }
-            if let Some(k) = key(sb, text_b.get(j).map_or("", String::as_str)) {
-                index.entry(k).or_default().push_back(j);
-            }
-        }
-        if index.is_empty() {
-            continue;
-        }
+            let tx = text_of(x);
+            !tx.trim().is_empty() && tx == text_of(y)
+        },
+        &|x, y| {
+            x.kind_name() == y.kind_name()
+                && x.geom.preset_name().is_some()
+                && x.geom.preset_name() == y.geom.preset_name()
+                && text_of(x).trim().is_empty()
+                && text_of(y).trim().is_empty()
+        },
+    ];
+    for pass in passes {
         for (i, sa) in a.shapes.iter().enumerate() {
             if used_a.get(i).copied().unwrap_or(true) {
                 continue;
             }
-            let Some(k) = key(sa, text_a.get(i).map_or("", String::as_str)) else { continue };
-            let Some(j) = index.get_mut(&k).and_then(VecDeque::pop_front) else { continue };
-            let Some(sb) = b.shapes.get(j) else { continue };
-            if let Some(u) = used_a.get_mut(i) {
-                *u = true;
+            let found = b.shapes.iter().enumerate().find(|(j, sb)| !used_b.get(*j).copied().unwrap_or(true) && pass(sa, sb));
+            if let Some((j, sb)) = found {
+                if let Some(u) = used_a.get_mut(i) {
+                    *u = true;
+                }
+                if let Some(u) = used_b.get_mut(j) {
+                    *u = true;
+                }
+                pairs.push((sa.id, sb.id));
             }
-            if let Some(u) = used_b.get_mut(j) {
-                *u = true;
-            }
-            pairs.push((sa.id, sb.id));
         }
     }
     pairs
 }
 
-/// What one [`morph_pairs`] pass matches shapes on.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-enum MorphKey {
-    Name(String),
-    Text(&'static str, String),
-    Geom(&'static str, String),
-}
-
 fn lerp(a: f64, b: f64, t: f64) -> f64 {
     let v = a + (b - a) * t;
     if v.is_finite() {
@@ -276,23 +256,13 @@ pub fn morph_frame(pres: &Presentation, a: &Slide, b: &Slide, t: f64, hidden_b:
         f.shapes.push((sh, old));
         id
     };
-    // Lookups by id, built once (the first shape or pair with an id wins, as a search would).
-    let paired_a: HashSet<ShapeId> = pairs.iter().map(|(ia, _)| *ia).collect();
-    let mut partner: HashMap<ShapeId, ShapeId> = HashMap::with_capacity(pairs.len());
-    for (ia, ib) in &pairs {
-        partner.entry(*ib).or_insert(*ia);
-    }
-    let mut a_by_id: HashMap<ShapeId, &Shape> = HashMap::with_capacity(a.shapes.len());
-    for x in &a.shapes {
-        a_by_id.entry(x.id).or_insert(x);
-    }
     for sa in &a.shapes {
-        if !paired_a.contains(&sa.id) {
+        if !pairs.iter().any(|(ia, _)| *ia == sa.id) {
             push(sa.clone(), true, 1.0 - s);
         }
     }
     for sb in &b.shapes {
-        let pair = partner.get(&sb.id).and_then(|ia| a_by_id.get(ia).copied());
+        let pair = pairs.iter().find(|(_, ib)| *ib == sb.id).and_then(|(ia, _)| a.shapes.iter().find(|x| x.id == *ia));
         let Some(sa) = pair else {
             if !hidden_b(sb.id) {
                 push(sb.clone(), false, s);

crates/anim/src/tests.rs

@@ -1155,58 +1155,3 @@ fn many_by_paragraph_animations_on_one_shape_share_paragraph_targets() {
     assert_eq!(tl.effects().len(), 6_000);
     assert_eq!(tl.paragraph_targets(ShapeId(1)), vec![0, 1, 2]);
 }
-
-#[test]
-fn morph_pairs_take_the_first_unused_match_in_slide_order() {
-    let mut a = Slide::default();
-    let mut b = Slide::default();
-    a.shapes = vec![shape(1, "Same"), shape(2, "Same"), shape(3, "Other")];
-    b.shapes = vec![shape(11, "Same"), shape(12, "Same"), shape(13, "Same")];
-    // By name first, in slide order; the shape of `a` left over pairs by kind and geometry with
-    // the shape of `b` left over.
-    assert_eq!(morph_pairs(&a, &b), [(ShapeId(1), ShapeId(11)), (ShapeId(2), ShapeId(12)), (ShapeId(3), ShapeId(13))]);
-}
-
-#[test]
-fn morph_of_large_slides_stays_linear() {
-    let n = 20_000u32;
-    let text = |i: u32, side: &str| Some(TextBody::from_text(&format!("{side} {i}")));
-    let mut a = Slide::default();
-    let mut b = Slide::default();
-    // Text no shape on the other slide shares: every pass looks for a partner and finds none.
-    a.shapes = (0..n).map(|i| Shape { text: text(i, "a"), ..shape(i + 1, "") }).collect();
-    b.shapes = (0..n).map(|i| Shape { text: text(i, "b"), ..shape(n + i + 1, "") }).collect();
-    // One named pair at opposite ends.
-    a.shapes[0].name = "Logo".into();
-    b.shapes[n as usize - 1].name = "Logo".into();
-    // No wall-clock bound (it would flake on a loaded runner): at this size a quadratic pairing
-    // takes minutes, so a regression shows as a test that hangs rather than a failed assertion.
-    assert_eq!(morph_pairs(&a, &b), [(ShapeId(1), ShapeId(2 * n))]);
-    let p = deckcraft_model::defaults::new_presentation(None);
-    let f = morph_frame(&p, &a, &b, 0.5, &|_| false);
-    // Every shape fades in place; the named pair differs in text, so it cross-fades as two.
-    assert_eq!(f.shapes.len(), 2 * n as usize);
-}
-
-#[test]
-fn paragraph_states_of_a_large_build_stay_linear() {
-    let n = 20_000usize;
-    let mut s = slide_with(vec![]);
-    let mut body = TextBody::from_text(&vec!["line"; n].join("\n"));
-    // One first-level paragraph owning every other paragraph.
-    for p in body.paragraphs.iter_mut().skip(1) {
-        p.level = 1;
-    }
-    s.shapes[0].text = Some(body);
-    let mut a = anim(1, AnimClass::Entrance, "fade", AnimStart::OnClick);
-    a.text_build = TextBuild::ByParagraph;
-    s.animations = vec![a];
-    let tl = Timeline::new(&s, W, H);
-    // No wall-clock bound, as above: a per-paragraph scan of the slide would take minutes here.
-    assert_eq!(tl.paragraph_targets(ShapeId(1)).len(), n);
-    for p in 0..n {
-        assert!(!tl.state(ShapeId(1), Some(p), 0, 0.0).visible);
-        assert!(tl.state(ShapeId(1), Some(p), 1, 0.0).visible);
-    }
-    assert_eq!(tl.animated_shapes(), [ShapeId(1)]);
-}

crates/anim/src/timeline.rs

@@ -103,41 +103,6 @@ pub struct Timeline {
     /// By-paragraph builds animate first-level paragraphs; deeper paragraphs follow their parent:
     /// (shape, member paragraph, owner paragraph).
     groups: Vec<(ShapeId, usize, usize)>,
-    /// Lookups built with the timeline, so evaluating a shape or paragraph costs its own effects
-    /// rather than a scan of every effect, group and colour on the slide.
-    index: TimelineIndex,
-}
-
-#[derive(Clone, Debug, Default)]
-struct TimelineIndex {
-    /// Effects (indices into `effects`, in order) by target shape and paragraph.
-    by_target: HashMap<(ShapeId, Option<usize>), Vec<usize>>,
-    /// Effects (indices into `effects`, in order) by target shape.
-    by_shape: HashMap<ShapeId, Vec<usize>>,
-    /// Owner paragraph of each member paragraph (the first group recorded wins).
-    owner: HashMap<(ShapeId, usize), usize>,
-    /// Groups (member, owner) by shape, in order.
-    groups_by_shape: HashMap<ShapeId, Vec<(usize, usize)>>,
-    /// Base colour by shape (the first recorded wins).
-    color: HashMap<ShapeId, Rgba>,
-}
-
-impl TimelineIndex {
-    fn build(effects: &[Effect], groups: &[(ShapeId, usize, usize)], colors: &[(ShapeId, Rgba)]) -> TimelineIndex {
-        let mut ix = TimelineIndex::default();
-        for (i, e) in effects.iter().enumerate() {
-            ix.by_target.entry((e.timing.shape, e.timing.paragraph)).or_default().push(i);
-            ix.by_shape.entry(e.timing.shape).or_default().push(i);
-        }
-        for &(shape, member, owner) in groups {
-            ix.owner.entry((shape, member)).or_insert(owner);
-            ix.groups_by_shape.entry(shape).or_default().push((member, owner));
-        }
-        for &(shape, c) in colors {
-            ix.color.entry(shape).or_insert(c);
-        }
-        ix
-    }
 }
 
 enum Status {
@@ -359,7 +324,6 @@ impl Timeline {
             };
             tl.colors.push((id, c));
         }
-        tl.index = TimelineIndex::build(&tl.effects, &tl.groups, &tl.colors);
         tl
     }
 
@@ -449,12 +413,8 @@ impl Timeline {
 
     /// Paragraph indices of `shape` animated separately (by-paragraph builds).
     pub fn paragraph_targets(&self, shape: ShapeId) -> Vec<usize> {
-        let mine = self.index.by_shape.get(&shape).map_or(&[][..], Vec::as_slice);
-        let mut v: Vec<usize> = mine.iter().filter_map(|&i| self.effects.get(i)).filter_map(|e| e.timing.paragraph).collect();
-        let owners: HashSet<usize> = v.iter().copied().collect();
-        if let Some(groups) = self.index.groups_by_shape.get(&shape) {
-            v.extend(groups.iter().filter(|(_, owner)| owners.contains(owner)).map(|(member, _)| *member));
-        }
+        let mut v: Vec<usize> = self.effects.iter().filter(|e| e.timing.shape == shape).filter_map(|e| e.timing.paragraph).collect();
+        v.extend(self.groups.iter().filter(|g| g.0 == shape && v.contains(&g.2)).map(|g| g.1).collect::<Vec<_>>());
         v.sort_unstable();
         v.dedup();
         v
@@ -462,8 +422,13 @@ impl Timeline {
 
     /// Shapes with any effect.
     pub fn animated_shapes(&self) -> Vec<ShapeId> {
-        let mut seen: HashSet<ShapeId> = HashSet::new();
-        self.effects.iter().map(|e| e.timing.shape).filter(|s| seen.insert(*s)).collect()
+        let mut v: Vec<ShapeId> = Vec::new();
+        for e in &self.effects {
+            if !v.contains(&e.timing.shape) {
+                v.push(e.timing.shape);
+            }
+        }
+        v
     }
 
     /// State of `shape` (or of one of its paragraphs, `para`) when `step` main steps have been
@@ -491,9 +456,9 @@ impl Timeline {
         triggers: &[TriggerPlay],
         stamps: &[StepStamp],
     ) -> AnimState {
-        let para = para.map(|p| self.index.owner.get(&(shape, p)).copied().unwrap_or(p));
-        let mine = self.index.by_target.get(&(shape, para)).map_or(&[][..], Vec::as_slice).iter().filter_map(|&i| self.effects.get(i));
-        let base_color = self.index.color.get(&shape).copied().unwrap_or(Rgba::rgb(0x15, 0x60, 0x82));
+        let para = para.map(|p| self.groups.iter().find(|g| g.0 == shape && g.1 == p).map(|g| g.2).unwrap_or(p));
+        let mine = self.effects.iter().filter(|e| e.timing.shape == shape && e.timing.paragraph == para);
+        let base_color = self.colors.iter().find(|(s, _)| *s == shape).map(|(_, c)| *c).unwrap_or(Rgba::rgb(0x15, 0x60, 0x82));
         let mut st = AnimState::default();
         // Initial visibility comes from the first effect in the Animation Pane order.
         let mut ordered: Vec<&Effect> = mine.collect();

crates/model/src/chart.rs

@@ -758,20 +758,17 @@ impl Chart {
     }
 
     fn stacked_value_range(&self, n: usize) -> (f64, f64) {
-        // Sums per category, from the values the series hold (an absent one adds nothing).
-        let (mut pos, mut neg) = (vec![0.0f64; n], vec![0.0f64; n]);
-        for s in &self.series {
-            for (i, v) in s.values.iter().enumerate().take(n) {
-                let v = v.unwrap_or(0.0);
-                if v >= 0.0 {
-                    pos[i] += v;
-                } else {
-                    neg[i] += v;
-                }
+        let mut lo: f64 = 0.0;
+        let mut hi: f64 = 0.0;
+        for i in 0..n {
+            let (mut p, mut m) = (0.0, 0.0);
+            for s in &self.series {
+                let v = s.values.get(i).copied().flatten().unwrap_or(0.0);
+                if v >= 0.0 { p += v } else { m += v }
             }
+            hi = hi.max(p);
+            lo = lo.min(m);
         }
-        let hi = pos.iter().fold(0.0f64, |a, &p| a.max(p));
-        let lo = neg.iter().fold(0.0f64, |a, &m| a.min(m));
         (lo, hi)
     }
 
@@ -1351,50 +1348,40 @@ impl Chart {
     /// The box chart's groups (distinct category labels in order of appearance; one unnamed
     /// group without categories) and, per series, each group's summary (None when it has no
     /// points).
-    ///
-    /// Each value is put in its group's bucket once (groups are found by name in a map), and the
-    /// series x groups result is held to [`MAX_BOX_CELLS`]: groups past it are left out.
     pub fn box_groups(&self) -> (Vec<String>, Vec<Vec<Option<BoxStats>>>) {
-        let max_groups = (MAX_BOX_CELLS / self.series.len().max(1)).max(1);
         let mut groups: Vec<String> = Vec::new();
-        let mut index: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
         for c in &self.categories {
-            if !index.contains_key(c.as_str()) && groups.len() < max_groups {
-                index.insert(c, groups.len());
+            if !groups.contains(c) {
                 groups.push(c.clone());
             }
         }
         if groups.is_empty() {
             groups.push(String::new());
-            index.insert("", 0);
         }
-        // A value past the categories belongs to the unnamed group, when there is one.
-        let past_end = index.get("").copied();
         let stats = self
             .series
             .iter()
             .map(|s| {
-                let mut buckets: Vec<Vec<f64>> = vec![Vec::new(); groups.len()];
-                for (i, v) in s.values.iter().enumerate() {
-                    let Some(v) = v.filter(|v| v.is_finite()) else { continue };
-                    let g = match self.categories.get(i) {
-                        Some(c) => index.get(c.as_str()).copied(),
-                        None => past_end,
-                    };
-                    if let Some(b) = g.and_then(|g| buckets.get_mut(g)) {
-                        b.push(v);
-                    }
-                }
-                buckets.into_iter().map(|pts| box_stats_by(pts, self.inclusive_quartiles)).collect()
+                groups
+                    .iter()
+                    .map(|g| {
+                        let pts: Vec<f64> = s
+                            .values
+                            .iter()
+                            .enumerate()
+                            .filter(|(i, _)| self.categories.get(*i).map_or(g.is_empty() || self.categories.is_empty(), |c| c == g))
+                            .filter_map(|(_, v)| *v)
+                            .filter(|v| v.is_finite())
+                            .collect();
+                        box_stats_by(pts, self.inclusive_quartiles)
+                    })
+                    .collect()
             })
             .collect();
         (groups, stats)
     }
 }
 
-/// Most series x group summaries [`Chart::box_groups`] makes.
-pub const MAX_BOX_CELLS: usize = 1_000_000;
-
 /// Widens the (min, max) extent `ext` to include `v`.
 fn widen(ext: &mut (f64, f64), v: f64) {
     ext.0 = ext.0.min(v);
@@ -1467,41 +1454,33 @@ impl Chart {
         let n = self.categories.len().max(s.values.len());
         let levels: Vec<&Vec<String>> = self.category_levels.iter().take(MAX_LEVELS).collect();
         // Each leaf's path from the top level down, blanks filled from the row above.
-        // Labels are shared, not copied: an outer label given once stands for every leaf under it.
-        use std::rc::Rc;
-        let empty: Rc<str> = Rc::from("");
-        let mut last: Vec<Rc<str>> = vec![empty.clone(); levels.len()];
-        let paths: Vec<Vec<Rc<str>>> = (0..n)
+        let mut last: Vec<String> = vec![String::new(); levels.len()];
+        let paths: Vec<Vec<String>> = (0..n)
             .map(|i| {
                 let mut path = Vec::with_capacity(levels.len() + 1);
                 for (d, lv) in levels.iter().enumerate().rev() {
                     let l = lv.get(i).map(|x| x.trim()).unwrap_or("");
                     if !l.is_empty() {
-                        last[d] = Rc::from(l);
+                        last[d] = l.to_string();
                         // A new outer label starts fresh inner groups.
                         for inner in last.iter_mut().take(d) {
-                            *inner = empty.clone();
+                            inner.clear();
                         }
                     }
                     path.push(last[d].clone());
                 }
-                path.push(self.categories.get(i).map_or_else(|| empty.clone(), |c| Rc::from(c.as_str())));
+                path.push(self.categories.get(i).cloned().unwrap_or_default());
                 path
             })
             .collect();
         let value = |i: usize| s.values.get(i).copied().flatten().filter(|v| v.is_finite()).unwrap_or(0.0).max(0.0);
-        fn build(rows: &[(usize, &[std::rc::Rc<str>])], value: &dyn Fn(usize) -> f64) -> Vec<TreeNode> {
+        fn build(rows: &[(usize, &[String])], value: &dyn Fn(usize) -> f64) -> Vec<TreeNode> {
             let mut out: Vec<TreeNode> = Vec::new();
             let mut i = 0;
             while i < rows.len() {
                 let (idx, path) = rows[i];
                 if path.len() <= 1 {
-                    out.push(TreeNode {
-                        name: path.first().map(|p| p.to_string()).unwrap_or_default(),
-                        value: value(idx),
-                        leaf: Some(idx),
-                        children: vec![],
-                    });
+                    out.push(TreeNode { name: path.first().cloned().unwrap_or_default(), value: value(idx), leaf: Some(idx), children: vec![] });
                     i += 1;
                     continue;
                 }
@@ -1510,14 +1489,14 @@ impl Chart {
                 while j < rows.len() && rows[j].1.len() > 1 && &rows[j].1[0] == head {
                     j += 1;
                 }
-                let sub: Vec<(usize, &[std::rc::Rc<str>])> = rows[i..j].iter().map(|(k, p)| (*k, &p[1..])).collect();
+                let sub: Vec<(usize, &[String])> = rows[i..j].iter().map(|(k, p)| (*k, &p[1..])).collect();
                 let children = build(&sub, value);
-                out.push(TreeNode { name: head.to_string(), value: children.iter().map(|c| c.value).sum(), leaf: None, children });
+                out.push(TreeNode { name: head.clone(), value: children.iter().map(|c| c.value).sum(), leaf: None, children });
                 i = j;
             }
             out
         }
-        let rows: Vec<(usize, &[Rc<str>])> = paths.iter().enumerate().map(|(i, p)| (i, p.as_slice())).collect();
+        let rows: Vec<(usize, &[String])> = paths.iter().enumerate().map(|(i, p)| (i, p.as_slice())).collect();
         build(&rows, &value)
     }
 }
@@ -1628,40 +1607,6 @@ mod chartex_tests {
         assert!(c.category_tree().iter().all(|n| n.leaf.is_some()));
     }
 
-    #[test]
-    fn large_box_hierarchy_and_stacked_charts_take_linear_work() {
-        // 50,000 distinct categories in one series: grouped through a map, one pass.
-        let n = 50_000;
-        let mut c = Chart::sample(ChartType::BoxWhisker);
-        c.series.truncate(1);
-        c.categories = (0..n).map(|i| format!("g{i}")).collect();
-        c.series[0].values = (0..n).map(|i| Some(i as f64)).collect();
-        let (groups, stats) = c.box_groups();
-        assert_eq!((groups.len(), stats[0].len()), (n, n));
-        assert!(stats[0].iter().all(Option::is_some));
-        // 2,000 series cap the groups so the result stays within MAX_BOX_CELLS.
-        c.series = vec![c.series[0].clone(); 2000];
-        let (groups, stats) = c.box_groups();
-        assert_eq!(groups.len(), MAX_BOX_CELLS / 2000);
-        assert!(stats.iter().all(|s| s.len() == groups.len()));
-        // One long outer label over 50,000 leaves is shared, not copied per leaf.
-        let mut t = Chart::sample(ChartType::Treemap);
-        t.series.truncate(1);
-        t.categories = (0..n).map(|i| format!("c{i}")).collect();
-        t.series[0].values = (0..n).map(|_| Some(1.0)).collect();
-        let mut outer = vec![String::new(); n];
-        outer[0] = "o".repeat(1 << 16);
-        t.category_levels = vec![outer];
-        let tree = t.category_tree();
-        assert_eq!(tree.len(), 1);
-        assert_eq!(tree[0].children.len(), n);
-        // Stacked sums over many sparse series.
-        let mut st = Chart::sample(ChartType::StackedBar);
-        st.categories = (0..n).map(|i| i.to_string()).collect();
-        st.series = (0..2000).map(|k| Series { values: vec![Some(1.0); if k == 0 { n } else { 1 }], ..Default::default() }).collect();
-        assert!(st.value_range().1 >= 2000.0, "{:?}", st.value_range());
-    }
-
     #[test]
     fn box_groups_follow_category_labels() {
         let c = Chart::sample(ChartType::BoxWhisker);

crates/model/src/numfmt.rs

@@ -143,14 +143,9 @@ fn group(digits: &str, sep: char) -> String {
     out
 }
 
-/// Longest number format applied, as in Excel (255 characters); a longer one formats as
-/// General, so a chart cannot make every label expand a huge format.
-pub const MAX_CODE_LEN: usize = 255;
-
 /// `v` formatted with the Excel number format `code` in language `lang` (axis labels: the text
 /// section of a format doesn't apply).
 pub fn format(code: &str, v: f64, lang: Option<&str>) -> String {
-    let code = if code.len() > MAX_CODE_LEN * 4 || code.chars().count() > MAX_CODE_LEN { "General" } else { code };
     let (sep, dec) = marks(lang);
     if !v.is_finite() {
         return String::new();
@@ -304,14 +299,6 @@ mod tests {
 
     const RUB: &str = r#"_-* #\ ##0\ "₽"_-;\-* #\ ##0\ "₽"_-;_-* "-"??\ "₽"_-;_-@_-"#;
 
-    #[test]
-    fn an_overlong_format_is_general() {
-        let code = "0".repeat(100_000);
-        assert_eq!(format(&code, 12.5, None), format("General", 12.5, None));
-        let ok = "0".repeat(MAX_CODE_LEN);
-        assert_eq!(format(&ok, 7.0, None).len(), MAX_CODE_LEN);
-    }
-
     #[test]
     fn scientific_subnormal() {
         assert_eq!(format("0.00E+00", 5e-324, None), "4.94E-324");