nitpick

Author: kane50613

takumi-helpers/src/utils.ts

@@ -4,11 +4,16 @@ import type { Node } from "./types";
 const defaultTimeout = 5000;
 const cssUrlPattern = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
 
+function isFetchableResourceUrl(value: string): boolean {
+  return value.startsWith("https://") || value.startsWith("http://");
+}
+
 function collectCssUrls(value: unknown, urls: Set<string>) {
   if (typeof value === "string") {
     for (const match of value.matchAll(cssUrlPattern)) {
-      if (match[2]) {
-        urls.add(match[2]);
+      const url = match[2]?.trim();
+      if (url && isFetchableResourceUrl(url)) {
+        urls.add(url);
       }
     }
   } else if (Array.isArray(value)) {
@@ -34,10 +39,7 @@ export function extractResourceUrls(node: Node): string[] {
     collectStyleUrls(current.style);
     collectStyleUrls(current.preset);
 
-    if (
-      current.type === "image" &&
-      (current.src.startsWith("https://") || current.src.startsWith("http://"))
-    ) {
+    if (current.type === "image" && isFetchableResourceUrl(current.src)) {
       urls.add(current.src);
       return;
     }

takumi-helpers/test/utils/extract-resource-urls.test.ts

@@ -40,4 +40,15 @@ describe("extractResourceUrls", () => {
 
     expect(extractResourceUrls(node)).toEqual(["https://example.com/good.png"]);
   });
+
+  test("ignores non-fetchable css url values", () => {
+    const validUrl = "https://example.com/background.png";
+    const node = container({
+      style: {
+        backgroundImage: `url(background), url("${validUrl}")`,
+      },
+    });
+
+    expect(extractResourceUrls(node)).toEqual([validUrl]);
+  });
 });

takumi/benches/effects.rs

@@ -22,7 +22,8 @@ fn run_effect_render(global: &GlobalContext, effect_tw: &str) {
     .global(global)
     .build();
 
-  let _image = render(options).unwrap();
+  let image = render(options).unwrap();
+  black_box(image);
 }
 
 fn bench_effects(c: &mut Criterion) {

takumi/benches/fixtures.rs

@@ -27,7 +27,8 @@ fn render_fixture(global: &GlobalContext, node: Node) {
     .global(global)
     .build();
 
-  let _image = render(options).unwrap();
+  let image = render(options).unwrap();
+  black_box(image);
 }
 
 fn simple_image_blit_fixture() -> Node {

takumi/benches/gradient.rs

@@ -31,7 +31,8 @@ fn run_gradient_render(global: &GlobalContext, background_image_str: &str) {
     .global(global)
     .build();
 
-  let _image = render(options).unwrap();
+  let image = render(options).unwrap();
+  black_box(image);
 }
 
 fn bench_gradients(c: &mut Criterion) {

takumi/src/error.rs

@@ -355,6 +355,15 @@ pub enum TakumiError {
   #[error("Invalid viewport: width or height cannot be 0")]
   InvalidViewport,
 
+  /// RGBA buffer length does not match `width * height * 4`.
+  #[error("invalid RGBA buffer length: expected {expected} bytes, got {actual}")]
+  InvalidRgbaBufferLength {
+    /// Actual RGBA byte length in the buffer.
+    actual: usize,
+    /// Expected RGBA byte length from dimensions.
+    expected: usize,
+  },
+
   /// Animated encode was requested without any frames.
   #[error("{format} animation must contain at least one frame")]
   EmptyAnimationFrames {

takumi/src/rendering/components/blur.rs

@@ -1,5 +1,5 @@
-use crate::Result;
 use crate::rendering::BufferPool;
+use crate::{Error, Result};
 
 /// Specifies the type of blur operation, which affects how the CSS radius is interpreted.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -138,7 +138,10 @@ pub(crate) fn apply_blur_rgba_bytes(
     .saturating_mul(height as usize)
     .saturating_mul(4);
   if data.len() != expected {
-    return Ok(());
+    return Err(Error::InvalidRgbaBufferLength {
+      actual: data.len(),
+      expected,
+    });
   }
 
   let Some(pass_params) = blur_pass_params(width, height, radius, blur_type, width as usize * 4)
@@ -373,3 +376,26 @@ fn compute_mul_shg(d: u32) -> (u32, i32) {
   let mul = ((1u64 << shg) as f64 / d as f64).round() as u32;
   (mul, shg)
 }
+
+#[cfg(test)]
+mod tests {
+  use super::{BlurType, apply_blur_rgba_bytes};
+  use crate::{Error, rendering::BufferPool};
+
+  #[test]
+  fn apply_blur_rgba_bytes_returns_error_for_invalid_buffer_length() {
+    let mut data = vec![0u8; 3];
+    let mut pool = BufferPool::default();
+
+    let err = apply_blur_rgba_bytes(&mut data, 1, 1, 4.0, BlurType::Filter, &mut pool)
+      .expect_err("expected invalid RGBA buffer length error");
+
+    match err {
+      Error::InvalidRgbaBufferLength { actual, expected } => {
+        assert_eq!(actual, 3);
+        assert_eq!(expected, 4);
+      }
+      _ => panic!("unexpected error variant: {err}"),
+    }
+  }
+}

takumi/src/rendering/stacking_context.rs

@@ -12,7 +12,7 @@ use crate::{
   },
   rendering::{
     BorderProperties, Canvas, CanvasSubcanvas, CanvasViewport, NodeMaskAction, Placement, Sizing,
-    blend_pixel, draw_debug_border, fast_div_255, prepare_node_mask,
+    blend_pixel, draw_debug_border, prepare_node_mask,
   },
 };
 
@@ -81,9 +81,9 @@ fn blend_plus_darker_pixel_raw_4(dst_px: &mut [u8], src_px: &[u8]) {
   let green = ((src_px[1] as u16 + dst_px[1] as u16).saturating_sub(255)) as u8;
   let blue = ((src_px[2] as u16 + dst_px[2] as u16).saturating_sub(255)) as u8;
 
-  dst_px[0] = fast_div_255(red as u32 * result_alpha as u32);
-  dst_px[1] = fast_div_255(green as u32 * result_alpha as u32);
-  dst_px[2] = fast_div_255(blue as u32 * result_alpha as u32);
+  dst_px[0] = red;
+  dst_px[1] = green;
+  dst_px[2] = blue;
   dst_px[3] = result_alpha;
 }