Method try_from

bindings/javascript/src/options.rs:76–148

(value: Options)

    type Error = JsError;

    fn try_from(value: Options) -> std::result::Result<Self, Self::Error> {
        Ok(css_inline::InlineOptions {
            inline_style_tags: value.inline_style_tags.unwrap_or(true),
            keep_style_tags: value.keep_style_tags.unwrap_or(false),
            keep_link_tags: value.keep_link_tags.unwrap_or(false),
            keep_at_rules: value.keep_at_rules.unwrap_or(false),
            minify_css: value.minify_css.unwrap_or(false),
            base_url: parse_url(value.base_url)?,
            load_remote_stylesheets: value.load_remote_stylesheets.unwrap_or(true),
            extra_css: value.extra_css.map(Cow::Owned),
            #[cfg(not(target_arch = "wasm32"))]
            cache: {
                if let Some(cache) = value.cache {
                    let size =
                        std::num::NonZeroUsize::new(cache.size as usize).ok_or_else(|| {
                            let reason =
                                "Cache size must be an integer greater than zero".to_string();
                            napi::Error::from_reason(reason)
                        })?;
                    Some(std::sync::Mutex::new(css_inline::StylesheetCache::new(
                        size,
                    )))
                } else {
                    None
                }
            },
            preallocate_node_capacity: if let Some(capacity) = value.preallocate_node_capacity {
                usize::try_from(capacity).map_err(|_| {
                    let reason = "Invalid capacity".to_string();
                    #[cfg(target_arch = "wasm32")]
                    {
                        JsValue::from_str(reason.as_str())
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    {
                        napi::Error::from_reason(reason)
                    }
                })?
            } else {
                32
            },
            resolver: {
                #[cfg(target_arch = "wasm32")]
                {
                    #[derive(Debug, Default)]
                    pub struct UnsupportedResolver;

                    impl css_inline::StylesheetResolver for UnsupportedResolver {
                        fn retrieve(&self, location: &str) -> css_inline::Result<String> {
                            let message = if location.starts_with("https")
                                || location.starts_with("http")
                            {
                                format!(
                                    "Loading remote stylesheets is not supported on WASM: {location}"
                                )
                            } else {
                                format!("Loading local files is not supported on WASM: {location}")
                            };