fret-ui-assets 0.1.0

UI render asset loading/caching helpers for Fret (images, SVGs, and resource registries).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use fret_core::{AppWindowId, Event};
use fret_runtime::{EffectSink, GlobalsHost, ModelHost, TimeHost};

use crate::image_asset_cache::{ImageAssetCacheHostExt, ImageAssetStats};
use crate::svg_asset_cache::{SvgAssetCacheHostExt, SvgAssetStats};

#[derive(Debug, Clone, Copy)]
pub struct UiAssetsBudgets {
    pub image_budget_bytes: u64,
    pub image_max_ready_entries: usize,
    pub svg_budget_bytes: u64,
    pub svg_max_ready_entries: usize,
}

impl Default for UiAssetsBudgets {
    fn default() -> Self {
        Self {
            image_budget_bytes: 64 * 1024 * 1024,
            image_max_ready_entries: 4096,
            svg_budget_bytes: 16 * 1024 * 1024,
            svg_max_ready_entries: 4096,
        }
    }
}

/// A tiny facade over the UI render-asset caches (images + SVGs).
///
/// This stays aligned with ADR 0004: assets are registered via effects at flush points and
/// referenced by stable IDs. This type only provides ergonomic wiring helpers.
pub struct UiAssets;

impl UiAssets {
    /// Ensure the global caches exist and apply budgets.
    pub fn configure<H: GlobalsHost>(host: &mut H, budgets: UiAssetsBudgets) {
        host.with_image_asset_cache(|cache, _host| {
            cache.set_budget_bytes(budgets.image_budget_bytes);
            cache.set_max_ready_entries(budgets.image_max_ready_entries);
        });

        host.with_svg_asset_cache(|cache, _host| {
            cache.set_budget_bytes(budgets.svg_budget_bytes);
            cache.set_max_ready_entries(budgets.svg_max_ready_entries);
        });
    }

    /// Drive the image cache state machine using the event pipeline.
    ///
    /// Notes:
    /// - SVG assets are registered directly through `UiServices::svg()` (no event driving needed).
    /// - This call is cheap for unrelated events.
    pub fn handle_event<H: GlobalsHost + TimeHost + EffectSink + ModelHost>(
        host: &mut H,
        window: AppWindowId,
        event: &Event,
    ) -> bool {
        host.with_image_asset_cache(|cache, host| {
            #[cfg(feature = "ui")]
            let key = match event {
                Event::ImageRegistered { token, .. } | Event::ImageRegisterFailed { token, .. } => {
                    cache.key_for_token(*token)
                }
                _ => None,
            };

            let changed = cache.handle_event(host, window, event);

            #[cfg(feature = "ui")]
            if let Some(key) = key {
                crate::image_source::notify_image_asset_key(host, key);
            }

            changed
        })
    }

    pub fn image_stats<H: GlobalsHost>(host: &mut H) -> ImageAssetStats {
        host.with_image_asset_cache(|cache, _host| cache.stats())
    }

    pub fn svg_stats<H: GlobalsHost>(host: &mut H) -> SvgAssetStats {
        host.with_svg_asset_cache(|cache, _host| cache.stats())
    }
}