moui_devtools

    Repo-local MoUI inspector snapshot summaries and debug formatters

    Download zip
    Author
    Version
    0.4.0
    License
    Apache-2.0
    Last updated
    1 hour ago
    Downloads
    402

    wzzc-dev/moui_devtools does not have a README file

    DevtoolsCacheTrace

    pub(all) struct DevtoolsCacheTrace {
    layout_hits_delta : Int
    layout_misses_delta : Int
    render_hits_delta : Int
    render_misses_delta : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsCacheTrace::equal

    DevtoolsCacheTrace::not_equal

    DevtoolsEffectTrace

    pub(all) struct DevtoolsEffectTrace {
    planned_delta : Int
    run_delta : Int
    send_delta : Int
    started_delta : Int
    completed_delta : Int
    cancelled_delta : Int
    ignored_delta : Int
    active_after : Int
    descriptors : Array[
    EffectDescriptor
    ]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsEffectTrace::equal

    DevtoolsEffectTrace::not_equal

    DevtoolsFrameTrace

    pub(all) struct DevtoolsFrameTrace {
    timed : Bool
    rebuild_passes : Int
    layout_passes : Int
    paint_passes : Int
    draw_builds : Int
    build_ms : Double
    layout_ms : Double
    paint_ms : Double
    draw_ms : Double
    total_ms : Double
    damage_kind : String
    damage_rect_count : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsFrameTrace::equal

    DevtoolsFrameTrace::not_equal

    DevtoolsMemoTrace

    pub(all) struct DevtoolsMemoTrace {
    available : Bool
    builds_delta : Int
    hits_delta : Int
    misses_delta : Int
    builds_after : Int
    hits_after : Int
    misses_after : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsMemoTrace::equal

    DevtoolsMemoTrace::not_equal

    fn DevtoolsMemoTrace::not_equal(x : DevtoolsMemoTrace, y : DevtoolsMemoTrace) -> Bool

    DevtoolsMessageTrace

    pub(all) struct DevtoolsMessageTrace {
    dispatched_delta : Int
    updated_delta : Int
    ignored_delta : Int
    enqueued_delta : Int
    drained_delta : Int
    pending_after : Int
    max_pending_after : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsMessageTrace::equal

    DevtoolsMessageTrace::not_equal

    DevtoolsTrace

    pub struct DevtoolsTrace {
    // private fields
    }

    DevtoolsTrace::capacity

    fn DevtoolsTrace::capacity(self : DevtoolsTrace) -> Int

    DevtoolsTrace::clear

    fn DevtoolsTrace::clear(self : DevtoolsTrace) -> Unit

    Drop retained samples and the comparison baseline. The next sample starts a new baseline rather than being diffed against discarded state.

    DevtoolsTrace::entries

    DevtoolsTrace::is_empty

    fn DevtoolsTrace::is_empty(self : DevtoolsTrace) -> Bool

    DevtoolsTrace::latest

    DevtoolsTrace::length

    fn DevtoolsTrace::length(self : DevtoolsTrace) -> Int

    DevtoolsTrace::new

    fn DevtoolsTrace::new(capacity? : Int, semantics_diff_limit? : Int) -> DevtoolsTrace

    Create a caller-owned trace. Retention and per-entry semantics-diff detail are bounded independently so a large tree cannot consume unbounded memory.

    DevtoolsTrace::record

    Record a sample after an event/message turn. Frame pass counters are always captured; timing stays zero unless record_frame receives profiled timing.

    DevtoolsTrace::record_frame

    Record a sample after AppRuntime::profile_draw_frame. The supplied timing belongs to that frame; pass counters still come from the Inspector snapshot.

    DevtoolsTrace::report

    DevtoolsTrace::semantics_diff_limit

    fn DevtoolsTrace::semantics_diff_limit(self : DevtoolsTrace) -> Int

    DevtoolsTraceEntry

    pub(all) struct DevtoolsTraceEntry {
    sequence : Int
    messages : DevtoolsMessageTrace
    effects : DevtoolsEffectTrace
    frame : DevtoolsFrameTrace
    caches : DevtoolsCacheTrace
    memo : DevtoolsMemoTrace
    semantics : SemanticsTreeDiff
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsTraceEntry::equal

    DevtoolsTraceEntry::not_equal

    DevtoolsTraceReport

    pub(all) struct DevtoolsTraceReport {
    capacity : Int
    semantics_diff_limit : Int
    entries : Array[DevtoolsTraceEntry]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    DevtoolsTraceReport::equal

    DevtoolsTraceReport::not_equal

    InspectorReport

    A structured Inspector view for DevTools clients. The runtime owns the detailed tree snapshots; this report keeps the five sections together so a tool can inspect one section without parsing a large summary string.

    InspectorReport::equal

    InspectorReport::from_snapshot

    InspectorReport::not_equal

    fn InspectorReport::not_equal(x : InspectorReport, y : InspectorReport) -> Bool

    SemanticsTreeChangeKind

    pub(all) enum SemanticsTreeChangeKind {
    SemanticsTreeAdded
    SemanticsTreeRemoved
    SemanticsTreeChanged
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    SemanticsTreeChangeKind::equal

    SemanticsTreeChangeKind::not_equal

    SemanticsTreeChangedField

    pub(all) enum SemanticsTreeChangedField {
    SemanticsTreeFieldRole
    SemanticsTreeFieldLabel
    SemanticsTreeFieldValue
    SemanticsTreeFieldFrame
    SemanticsTreeFieldDepth
    SemanticsTreeFieldChildCount
    SemanticsTreeFieldActionCount
    SemanticsTreeFieldFocusable
    SemanticsTreeFieldSelected
    SemanticsTreeFieldChecked
    SemanticsTreeFieldExpanded
    SemanticsTreeFieldDisabled
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    SemanticsTreeChangedField::equal

    SemanticsTreeChangedField::not_equal

    SemanticsTreeDiff

    pub(all) struct SemanticsTreeDiff {
    baseline : Bool
    added_count : Int
    removed_count : Int
    changed_count : Int
    dropped_count : Int
    entries : Array[SemanticsTreeDiffEntry]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    SemanticsTreeDiff::equal

    SemanticsTreeDiff::not_equal

    fn SemanticsTreeDiff::not_equal(x : SemanticsTreeDiff, y : SemanticsTreeDiff) -> Bool

    SnapshotHistory

    pub struct SnapshotHistory {
    // private fields
    }

    SnapshotHistory::debug_text

    fn SnapshotHistory::debug_text(self : SnapshotHistory) -> String

    SnapshotHistory::latest

    SnapshotHistory::length

    fn SnapshotHistory::length(self : SnapshotHistory) -> Int

    SnapshotHistory::new

    SnapshotSummary

    pub(all) struct SnapshotSummary {
    width : Double
    height : Double
    dirty_count : Int
    draw_command_count : Int
    view_node_count : Int
    layout_node_count : Int
    semantics_node_count : Int
    active_effect_task_count : Int
    active_subscription_count : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    SnapshotSummary::equal

    SnapshotSummary::from_snapshot

    SnapshotSummary::not_equal

    fn SnapshotSummary::not_equal(x : SnapshotSummary, y : SnapshotSummary) -> Bool

    SnapshotSummary::text

    fn SnapshotSummary::text(self : SnapshotSummary) -> String

    inspector_report

    inspector_report_text

    fn inspector_report_text(snapshot :
    InspectorSnapshot
    ) -> String

    Render a compact, sectioned Inspector report for terminal output and overlays. Full node details remain available through inspector_report and snapshot_report_json.

    snapshot_debug_text

    fn snapshot_debug_text(snapshot :
    InspectorSnapshot
    ) -> String

    snapshot_json

    fn snapshot_json(snapshot :
    InspectorSnapshot
    , indent? : Int) -> String

    snapshot_report_json

    fn snapshot_report_json(snapshot :
    InspectorSnapshot
    , indent? : Int) -> String

    snapshot_summary

    trace_report_json

    fn trace_report_json(trace : DevtoolsTrace, indent? : Int) -> String

    trace_report_text

    fn trace_report_text(trace : DevtoolsTrace, max_entries? : Int) -> String

    Format the most recent trace samples. Node-level diff detail is limited so terminal and in-app diagnostics stay readable; JSON retains every stored entry within the recorder's configured bounds.