Hello
+who am i
+
](https://github.com/Stranger6667/css-inline/actions/workflows/build.yml)
+[
](https://github.com/Stranger6667/css-inline/packages)
+
+Java bindings for the high-performance `css-inline` library that inlines CSS into HTML 'style' attributes.
+
+This library is designed for scenarios such as preparing HTML emails or embedding HTML into third-party web pages.
+
+Transforms HTML like this:
+
+```html
+
+
+
+
+
+ Big Text
+ + +``` + +into: + +```html + + + +Big Text
+ + +``` + +## Features + +- Uses reliable components from Mozilla's Servo project +- Inlines CSS from `style` and `link` tags +- Removes `style` and `link` tags +- Resolves external stylesheets (including local files) +- Optionally caches external stylesheets +- Works on Linux, Windows, and macOS +- Supports HTML5 & CSS3 + +## Installation + +This package is available on [GitHub Packages](https://github.com/Stranger6667/css-inline/packages). + +> Maven Central publishing is in the works + +### Setup + +GitHub Packages requires authentication even for public packages. See the [GitHub documentation](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-gradle-registry#authenticating-to-github-packages) for authentication setup. + +**Gradle:** +```gradle +repositories { + maven { + url = uri("https://maven.pkg.github.com/Stranger6667/css-inline") + credentials { + username = project.findProperty("gpr.user") ?: System.getenv("USERNAME") + password = project.findProperty("gpr.key") ?: System.getenv("TOKEN") + } + } +} + +dependencies { + implementation 'org.css-inline:css-inline:0.15.0' +} +``` + +**Maven:** +```xml +Big Text
+ + """; + + String inlined = CssInline.inline(html); + System.out.println(inlined); + } +} +``` + +You can also configure the inlining process: + +```java +import org.cssinline.CssInline; +import org.cssinline.CssInlineConfig; + +public class ConfigExample { + public static void main(String[] args) { + String html = "..."; + + CssInlineConfig config = new CssInlineConfig.Builder() + .setLoadRemoteStylesheets(false) + .setKeepStyleTags(true) + .setBaseUrl("https://example.com/") + .build(); + + String inlined = CssInline.inline(html, config); + } +} +``` + +- **`setInlineStyleTags(boolean)`** - Inline CSS from ` + + + +Big Text
+ +``` + +The `data-css-inline="ignore"` attribute also allows you to skip `link` and `style` tags: + +```html + + + + + +Big Text
+ +``` + +Alternatively, you may keep `style` from being removed by using the `data-css-inline="keep"` attribute. +This is useful if you want to keep `@media` queries for responsive emails in separate `style` tags: + +```html + + + + + +Big Text
+ +``` + +Such tags will be kept in the resulting HTML even if the `keepStyleTags` option is set to `false`. + +## Performance + +`css-inline` is powered by efficient tooling from Mozilla's Servo project to provide high-performance CSS inlining for Java applications. + +Here is the performance comparison: + +| | Size | `css-inline 0.15.0` | `CSSBox 5.0.0` | +|-------------|---------|---------------------|------------------------| +| Basic | 230 B | 7.67 µs | 209.93 µs (**27.37x**) | +| Realistic-1 | 8.58 KB | 123.18 µs | 1.92 ms (**15.58x**) | +| Realistic-2 | 4.3 KB | 77.74 µs | 608.65 µs (**7.82x**) | +| GitHub page | 1.81 MB | 168.43 ms | 316.21 ms (**1.87x**) | + +The benchmarking code is available in the `src/jmh/java/org/cssinline/CSSInlineBench.java` file. The benchmarks were conducted using the stable `rustc 1.87`, `OpenJDK 24.0.1` on Ryzen 9 9950X. + +## License + +This project is licensed under the terms of the [MIT license](https://opensource.org/licenses/MIT). diff --git a/bindings/java/build.gradle b/bindings/java/build.gradle new file mode 100644 index 00000000..a7882a38 --- /dev/null +++ b/bindings/java/build.gradle @@ -0,0 +1,108 @@ +plugins { + id 'java-library' + id 'maven-publish' + id 'me.champeau.jmh' version '0.7.3' +} + +group = 'org.css-inline' +version = System.getenv('VERSION') ?: '0.15.0-SNAPSHOT' + +java { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 +} + +repositories { + mavenCentral() +} + +dependencies { + testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0' + implementation 'com.google.code.gson:gson:2.10.1' + + jmh 'org.openjdk.jmh:jmh-core:1.37' + jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37' + + jmh 'net.sf.cssbox:cssbox:5.0.0' + jmh 'net.sf.cssbox:jstyleparser:3.5.0' + jmh 'com.fasterxml.jackson.core:jackson-core:2.15.2' + jmh 'com.fasterxml.jackson.core:jackson-databind:2.15.2' +} + +publishing { + repositories { + maven { + name = "GitHubPackages" + url = uri("https://maven.pkg.github.com/Stranger6667/css-inline") + credentials { + username = System.getenv("GITHUB_ACTOR") + password = System.getenv("GITHUB_TOKEN") + } + } + } + + publications { + maven(MavenPublication) { + from components.java + + pom { + name = 'CSS Inline Java' + description = 'Java bindings for css-inline - a high-performance CSS inlining library' + url = 'https://css-inline.org' + + licenses { + license { + name = 'MIT License' + url = 'https://opensource.org/licenses/MIT' + } + } + + developers { + developer { + id = 'stranger6667' + name = 'Dmitry Dygalo' + email = 'dmitry@dygalo.dev' + } + } + + scm { + connection = 'scm:git:git://github.com/Stranger6667/css-inline.git' + developerConnection = 'scm:git:ssh://github.com:Stranger6667/css-inline.git' + url = 'https://github.com/Stranger6667/css-inline/tree/master' + } + } + } + } +} + +jmh { + jmhVersion = '1.37' + + def baseArgs = [ + '-server', + '--add-opens=java.base/sun.misc=ALL-UNNAMED', + '--add-exports=java.base/sun.misc=ALL-UNNAMED', + '--enable-native-access=ALL-UNNAMED' + ] + + def nativeDir = file('target/release') + if (nativeDir.exists()) { + jvmArgs = baseArgs + ["-Djava.library.path=${nativeDir.absolutePath}"] + println "Using native library path: ${nativeDir.absolutePath}" + } else { + jvmArgs = baseArgs + println "Native dir not found, using bundled libraries" + } +} + +test { + useJUnitPlatform() + + def nativeDir = file('target/release') + if (nativeDir.exists()) { + jvmArgs += "-Djava.library.path=${nativeDir.absolutePath}" + println "Test using native library path: ${nativeDir.absolutePath}" + } else { + println "Test using bundled libraries" + } +} diff --git a/bindings/java/rustfmt.toml b/bindings/java/rustfmt.toml new file mode 100644 index 00000000..bf772232 --- /dev/null +++ b/bindings/java/rustfmt.toml @@ -0,0 +1,2 @@ +imports_granularity = "Crate" +edition = "2021" diff --git a/bindings/java/settings.gradle b/bindings/java/settings.gradle new file mode 100644 index 00000000..f2a23080 --- /dev/null +++ b/bindings/java/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'css-inline' diff --git a/bindings/java/src/jmh/java/org/cssinline/CSSBoxInliner.java b/bindings/java/src/jmh/java/org/cssinline/CSSBoxInliner.java new file mode 100644 index 00000000..c5cdfd73 --- /dev/null +++ b/bindings/java/src/jmh/java/org/cssinline/CSSBoxInliner.java @@ -0,0 +1,45 @@ +package org.cssinline; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import org.fit.cssbox.css.CSSNorm; +import org.fit.cssbox.css.DOMAnalyzer; +import org.fit.cssbox.css.NormalOutput; +import org.fit.cssbox.css.Output; +import org.fit.cssbox.io.DOMSource; +import org.fit.cssbox.io.DefaultDOMSource; +import org.fit.cssbox.io.DefaultDocumentSource; +import org.fit.cssbox.io.DocumentSource; +import org.w3c.dom.Document; + +public class CSSBoxInliner { + + public String inline(String html) throws Exception { + String dataUrl = "data:text/html;charset=utf-8," + java.net.URLEncoder.encode(html, "UTF-8"); + DocumentSource docSource = new DefaultDocumentSource(dataUrl); + + try { + DOMSource parser = new DefaultDOMSource(docSource); + Document doc = parser.parse(); + + DOMAnalyzer da = new DOMAnalyzer(doc, docSource.getURL()); + da.attributesToStyles(); + da.addStyleSheet(null, CSSNorm.stdStyleSheet(), DOMAnalyzer.Origin.AGENT); + da.addStyleSheet(null, CSSNorm.userStyleSheet(), DOMAnalyzer.Origin.AGENT); + da.getStyleSheets(); + + da.stylesToDomInherited(); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + PrintStream ps = new PrintStream(baos, true, "UTF-8"); + Output out = new NormalOutput(doc); + out.dumpTo(ps); + ps.close(); + + return baos.toString("UTF-8"); + + } finally { + docSource.close(); + } + } +} diff --git a/bindings/java/src/jmh/java/org/cssinline/CSSInlineBench.java b/bindings/java/src/jmh/java/org/cssinline/CSSInlineBench.java new file mode 100644 index 00000000..12efd0b7 --- /dev/null +++ b/bindings/java/src/jmh/java/org/cssinline/CSSInlineBench.java @@ -0,0 +1,72 @@ +package org.cssinline; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +@State(Scope.Benchmark) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Fork(value = 1, jvmArgs = {"-server"}) +@Warmup(iterations = 1, time = 10, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 3, time = 10, timeUnit = TimeUnit.SECONDS) +public class CSSInlineBench { + + @Param({"simple", "merging", "double_quotes", "big_email_1", "big_email_2", "big_page"}) + public String name; + + private static MapUnlike {@link #inline(String, CssInlineConfig)}, this method works with HTML fragments + * (elements without <html>, <head>, or <body> tags) and applies the + * provided CSS directly without parsing <style> or <link> tags. + * + * @param fragment the HTML fragment to process + * @param css the CSS rules to inline + * @param cfg the configuration object specifying inlining behavior + * @return the HTML fragment with CSS styles inlined + * @throws CssInlineException if an error occurs during processing + */ + public static String inlineFragment(String fragment, String css, CssInlineConfig cfg) { + return nativeInlineFragment(fragment, css, cfg); + } + + /** + * Inlines the provided CSS into an HTML fragment using default configuration. + * + *
Unlike {@link #inline(String)}, this method works with HTML fragments
+ * (elements without <html>, <head>, or <body> tags) and applies the
+ * provided CSS directly without parsing <style> or <link> tags.
+ *
+ * @param fragment the HTML fragment to process
+ * @param css the CSS rules to inline
+ * @return the HTML fragment with CSS styles inlined
+ * @throws CssInlineException if an error occurs during processing
+ */
+ public static String inlineFragment(String fragment, String css) {
+ return inlineFragment(fragment, css, new CssInlineConfig.Builder().build());
+ }
+}
diff --git a/bindings/java/src/main/java/org/cssinline/CssInlineConfig.java b/bindings/java/src/main/java/org/cssinline/CssInlineConfig.java
new file mode 100644
index 00000000..557e2b15
--- /dev/null
+++ b/bindings/java/src/main/java/org/cssinline/CssInlineConfig.java
@@ -0,0 +1,175 @@
+package org.cssinline;
+
+/** Configuration options for CSS inlining. */
+public class CssInlineConfig {
+ /** Whether to inline CSS from "style" tags. */
+ public final boolean inlineStyleTags;
+
+ /** Keep "style" tags after inlining. */
+ public final boolean keepStyleTags;
+
+ /** Keep "link" tags after inlining. */
+ public final boolean keepLinkTags;
+
+ /** Whether remote stylesheets should be loaded or not. */
+ public final boolean loadRemoteStylesheets;
+
+ /** Used for loading external stylesheets via relative URLs. */
+ public final String baseUrl;
+
+ /** Additional CSS to inline. */
+ public final String extraCss;
+
+ /** External stylesheet cache size. */
+ public final int cacheSize;
+
+ /** Pre-allocate capacity for HTML nodes during parsing. */
+ public final int preallocateNodeCapacity;
+
+ private CssInlineConfig(boolean inlineStyleTags, boolean keepStyleTags, boolean keepLinkTags,
+ boolean loadRemoteStylesheets, String baseUrl, String extraCss, int cacheSize,
+ int preallocateNodeCapacity) {
+ this.inlineStyleTags = inlineStyleTags;
+ this.keepStyleTags = keepStyleTags;
+ this.keepLinkTags = keepLinkTags;
+ this.loadRemoteStylesheets = loadRemoteStylesheets;
+ this.baseUrl = baseUrl;
+ this.extraCss = extraCss;
+ this.cacheSize = cacheSize;
+ this.preallocateNodeCapacity = preallocateNodeCapacity;
+ }
+
+ /**
+ * Builder for creating {@link CssInlineConfig} instances.
+ */
+ public static class Builder {
+ private boolean inlineStyleTags = true;
+ private boolean keepStyleTags = false;
+ private boolean keepLinkTags = false;
+ private boolean loadRemoteStylesheets = true;
+ private String baseUrl = null;
+ private String extraCss = null;
+ private int cacheSize = 0;
+ private int preallocateNodeCapacity = 32;
+
+ /**
+ * Creates a new builder with default configuration values.
+ */
+ public Builder() {
+ // Default constructor for builder
+ }
+
+ /**
+ * Whether to inline CSS from "style" tags.
+ * Sometimes HTML may include boilerplate styles that are not applicable
+ * in every scenario and it is useful to ignore them and use extraCss instead.
+ *
+ * @param b true to inline CSS from style tags, false to ignore them
+ * @return this builder instance for method chaining
+ */
+ public Builder setInlineStyleTags(boolean b) {
+ this.inlineStyleTags = b;
+ return this;
+ }
+
+ /**
+ * Keep "style" tags after inlining.
+ *
+ * @param b true to preserve style tags, false to remove them
+ * @return this builder instance for method chaining
+ */
+ public Builder setKeepStyleTags(boolean b) {
+ this.keepStyleTags = b;
+ return this;
+ }
+
+ /**
+ * Keep "link" tags after inlining.
+ *
+ * @param b true to preserve link tags, false to remove them
+ * @return this builder instance for method chaining
+ */
+ public Builder setKeepLinkTags(boolean b) {
+ this.keepLinkTags = b;
+ return this;
+ }
+
+ /**
+ * Whether remote stylesheets should be loaded or not.
+ *
+ * @param b true to load external stylesheets, false to ignore them
+ * @return this builder instance for method chaining
+ */
+ public Builder setLoadRemoteStylesheets(boolean b) {
+ this.loadRemoteStylesheets = b;
+ return this;
+ }
+
+ /**
+ * Used for loading external stylesheets via relative URLs.
+ *
+ * @param url the base URL as a string, or null to use no base URL
+ * @return this builder instance for method chaining
+ */
+ public Builder setBaseUrl(String url) {
+ this.baseUrl = url;
+ return this;
+ }
+
+ /**
+ * Additional CSS to inline.
+ *
+ * @param css additional CSS rules as a string, or null for no extra CSS
+ * @return this builder instance for method chaining
+ */
+ public Builder setExtraCss(String css) {
+ this.extraCss = css;
+ return this;
+ }
+
+ /**
+ * External stylesheet cache size.
+ *
+ * @param size
+ * cache size, must be non-negative
+ * @return this builder instance for method chaining
+ * @throws IllegalArgumentException
+ * if size is negative
+ */
+ public Builder setCacheSize(int size) {
+ if (size < 0) {
+ throw new IllegalArgumentException("Cache size must be non-negative, got: " + size);
+ }
+ this.cacheSize = size;
+ return this;
+ }
+
+ /**
+ * Pre-allocate capacity for HTML nodes during parsing. Can improve performance
+ * when you have an estimate of the number of nodes in your HTML document.
+ *
+ * @param cap
+ * initial node capacity, must be positive
+ * @return this builder instance for method chaining
+ * @throws IllegalArgumentException
+ * if cap is zero or negative
+ */
+ public Builder setPreallocateNodeCapacity(int cap) {
+ if (cap <= 0) {
+ throw new IllegalArgumentException("Preallocate node capacity must be positive, got: " + cap);
+ }
+ this.preallocateNodeCapacity = cap;
+ return this;
+ }
+
+ /**
+ * Creates a new {@link CssInlineConfig} instance with the current builder settings.
+ *
+ * @return a new immutable configuration instance
+ */
+ public CssInlineConfig build() {
+ return new CssInlineConfig(inlineStyleTags, keepStyleTags, keepLinkTags, loadRemoteStylesheets, baseUrl,
+ extraCss, cacheSize, preallocateNodeCapacity);
+ }
+ }
+}
diff --git a/bindings/java/src/main/java/org/cssinline/CssInlineException.java b/bindings/java/src/main/java/org/cssinline/CssInlineException.java
new file mode 100644
index 00000000..dc3db31a
--- /dev/null
+++ b/bindings/java/src/main/java/org/cssinline/CssInlineException.java
@@ -0,0 +1,33 @@
+package org.cssinline;
+
+/**
+ * Exception thrown when CSS inlining operations fail.
+ *
+ * This runtime exception is thrown when errors occur during CSS processing,
+ * HTML parsing, or stylesheet loading.
+ */
+public class CssInlineException extends RuntimeException {
+
+ /**
+ * Creates a new exception with the specified error message.
+ *
+ * @param message
+ * the error message describing what went wrong
+ */
+ public CssInlineException(String message) {
+ super(message);
+ }
+
+ /**
+ * Creates a new exception with the specified error message and underlying
+ * cause.
+ *
+ * @param message
+ * the error message describing what went wrong
+ * @param cause
+ * the underlying exception that caused this error
+ */
+ public CssInlineException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/bindings/java/src/main/java/org/cssinline/NativeLibraryLoader.java b/bindings/java/src/main/java/org/cssinline/NativeLibraryLoader.java
new file mode 100644
index 00000000..6785fad7
--- /dev/null
+++ b/bindings/java/src/main/java/org/cssinline/NativeLibraryLoader.java
@@ -0,0 +1,91 @@
+package org.cssinline;
+
+import java.io.*;
+import java.nio.file.*;
+
+class NativeLibraryLoader {
+ private static final String LIBRARY_NAME = "css_inline";
+ private static boolean loaded = false;
+
+ static synchronized void loadLibrary() {
+ if (loaded)
+ return;
+
+ try {
+ // Try system library first (for development)
+ System.loadLibrary(LIBRARY_NAME);
+ loaded = true;
+ return;
+ } catch (UnsatisfiedLinkError e) {
+ // Fall back to bundled library
+ }
+
+ String platform = detectPlatform();
+ String libraryPath = "/org/cssinline/native/" + platform + "/" + getLibraryFileName();
+
+ try (InputStream is = NativeLibraryLoader.class.getResourceAsStream(libraryPath)) {
+ if (is == null) {
+ throw new UnsatisfiedLinkError("Native library not found: " + libraryPath
+ + ". Available platforms: linux-x86_64, darwin-x86_64, darwin-aarch64, win32-x86_64");
+ }
+
+ // Extract to temporary file
+ Path tempDir = Files.createTempDirectory("css-inline-native");
+ Path tempFile = tempDir.resolve(getLibraryFileName());
+ Files.copy(is, tempFile, StandardCopyOption.REPLACE_EXISTING);
+
+ // Load library
+ System.load(tempFile.toAbsolutePath().toString());
+ loaded = true;
+
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+ try {
+ Files.deleteIfExists(tempFile);
+ Files.deleteIfExists(tempDir);
+ } catch (IOException ignored) {
+ }
+ }));
+
+ } catch (IOException e) {
+ throw new UnsatisfiedLinkError("Failed to load native library: " + e.getMessage());
+ }
+ }
+
+ private static String detectPlatform() {
+ String os = System.getProperty("os.name").toLowerCase();
+ String arch = System.getProperty("os.arch").toLowerCase();
+
+ String osName;
+ if (os.contains("windows")) {
+ osName = "win32";
+ } else if (os.contains("mac") || os.contains("darwin")) {
+ osName = "darwin";
+ } else if (os.contains("linux")) {
+ osName = "linux";
+ } else {
+ throw new UnsatisfiedLinkError("Unsupported OS: " + os);
+ }
+
+ String archName;
+ if (arch.contains("amd64") || arch.contains("x86_64")) {
+ archName = "x86_64";
+ } else if (arch.contains("aarch64") || arch.contains("arm64")) {
+ archName = "aarch64";
+ } else {
+ throw new UnsatisfiedLinkError("Unsupported architecture: " + arch);
+ }
+
+ return osName + "-" + archName;
+ }
+
+ private static String getLibraryFileName() {
+ String os = System.getProperty("os.name").toLowerCase();
+ if (os.contains("windows")) {
+ return LIBRARY_NAME + ".dll";
+ } else if (os.contains("mac") || os.contains("darwin")) {
+ return "lib" + LIBRARY_NAME + ".dylib";
+ } else {
+ return "lib" + LIBRARY_NAME + ".so";
+ }
+ }
+}
diff --git a/bindings/java/src/main/rust/lib.rs b/bindings/java/src/main/rust/lib.rs
new file mode 100644
index 00000000..3a1b3615
--- /dev/null
+++ b/bindings/java/src/main/rust/lib.rs
@@ -0,0 +1,154 @@
+use core::fmt;
+use css_inline::{CSSInliner, StylesheetCache};
+use jni::{
+ JNIEnv,
+ errors::Result as JNIResult,
+ objects::{JClass, JObject, JString},
+ sys::jstring,
+};
+use std::{borrow::Cow, num::NonZeroUsize};
+
+trait JNIExt {
+ fn get_rust_string(&mut self, obj: &JString) -> String;
+ fn to_jstring(&mut self, obj: String) -> jstring;
+ fn get_bool_field(&mut self, obj: &JObject, name: &str) -> JNIResult No styles No styles HiHello
";
+
+ String out = CssInline.inline(html);
+
+ assertTrue(out.contains("style=\"color: blue;\""), "Output should inline styles for h1, got: " + out);
+ }
+
+ @Test
+ void extraCssAddsBackground() {
+ String html = "Hello
";
+
+ CssInlineConfig cfg = new CssInlineConfig.Builder().setExtraCss("h1 { color: blue; }").build();
+
+ String out = CssInline.inline(html, cfg);
+
+ assertTrue(out.contains("style=\"color: blue;\""), "Output should inline styles for h1, got: " + out);
+ }
+
+ @Test
+ void validBaseUrlParses() {
+ CssInlineConfig cfg = new CssInlineConfig.Builder().setBaseUrl("https://example.com/styles/").build();
+
+ String in = "Bold
";
+
+ CssInlineConfig cfg = new CssInlineConfig.Builder().setKeepStyleTags(true).build();
+
+ String out = CssInline.inline(html, cfg);
+ assertTrue(out.contains(""), "Expected to keep original style tags");
+ assertTrue(out.contains("style=\"font-weight: bold;\""));
+ }
+
+ @Test
+ void negativeCacheSizeThrows() {
+ IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> new CssInlineConfig.Builder().setCacheSize(-1));
+ assertEquals("Cache size must be non-negative, got: -1", ex.getMessage());
+ }
+
+ @Test
+ void zeroOrNegativePreallocateCapacityThrows() {
+ IllegalArgumentException ex1 = assertThrows(IllegalArgumentException.class,
+ () -> new CssInlineConfig.Builder().setPreallocateNodeCapacity(0));
+ assertEquals("Preallocate node capacity must be positive, got: 0", ex1.getMessage());
+
+ IllegalArgumentException ex2 = assertThrows(IllegalArgumentException.class,
+ () -> new CssInlineConfig.Builder().setPreallocateNodeCapacity(-5));
+ assertEquals("Preallocate node capacity must be positive, got: -5", ex2.getMessage());
+ }
+
+ @Test
+ void validConfigurationBuilds() {
+ assertDoesNotThrow(() -> {
+ CssInlineConfig cfg = new CssInlineConfig.Builder().setCacheSize(0).setCacheSize(100)
+ .setPreallocateNodeCapacity(1).build();
+ });
+ }
+
+ @Test
+ void inlineFragmentBasic() {
+ String fragment = """
+ ";
+ String css = "h1 { color: blue; font-size: 16px; }";
+
+ CssInlineConfig config = new CssInlineConfig.Builder()
+ .setExtraCss("div { margin: 10px; }")
+ .build();
+
+ String result = CssInline.inlineFragment(fragment, css, config);
+
+ assertTrue(result.contains("h1 style=\"color: blue;font-size: 16px;\""),
+ "Should inline h1 styles");
+ assertTrue(result.contains("div style=\"margin: 10px;\""),
+ "Should apply extra CSS");
+ }
+
+ @Test
+ void inlineFragmentEmpty() {
+ String result = CssInline.inlineFragment("", "");
+
+ assertEquals("", result, "Empty fragment and CSS should return empty string");
+ }
+}
diff --git a/bindings/javascript/wasm/index.html b/bindings/javascript/wasm/index.html
index 3b7a9bef..4f26b3ba 100644
--- a/bindings/javascript/wasm/index.html
+++ b/bindings/javascript/wasm/index.html
@@ -5,11 +5,11 @@
Test
- css-inline leverages Mozilla's Servo project components and works with - Rust, Python, Ruby, JavaScript, and C. The playground below is powered - by WebAssembly allows direct browser interaction with the library. Edit - the HTML in the text area and click "Inline" to view the results - instantly. + css-inline uses components from Mozilla's Servo project and provides + bindings for Rust, Python, Ruby, JavaScript, Java, and C. The playground + runs the library compiled to WebAssembly in the browser. Paste HTML with + CSS into the text area and click "Inline" to process the output.