From a16eaa05621cb45203f0abe27549029eed84ff8e Mon Sep 17 00:00:00 2001 From: sindresorhus Date: Sat, 21 Nov 2026 06:05:24 +0000 Subject: [PATCH 1/2] feat: per-case capture bounds, settle frames, frame clock and viewport size classes What the remaining Raft design-system galleries need from vcase: - @VCase(maxWidth, maxHeight): dp bounds of a component capture, replacing the host's CaptureSize.WrapContent bounds (galleries wider than 1200dp). - @VCase(settleFrames, frameIntervalMs): frames rendered before the captured one, and a fixed frame step; frameIntervalMs = 0 renders every frame at time 0, as RaftScreenshot's scene.render() does. The measure pass keeps the host's settle count. - ManifestViewport.sizeClass / VCaseViewport.sizeClass (VCaseSizeClass): the layout mode a host pins for a viewport (e.g. a wide type scale), combined with the existing pointer axis for mouse sizing. All optional and omitted from the manifest while unset (cases[].capture, viewport[].sizeClass), so existing manifests and goldens are unchanged. Sample gains three cases (wide toolbar, settled tooltip, desktop buttons with both pointers). ci.yml can be dispatched on a branch. Signed-off-by: sindresorhus --- .github/workflows/ci.yml | 2 + README.md | 52 ++++++++++- docs/design.md | 9 +- docs/pilot-raft-mobile.md | 30 ++++++- .../kotlin/dev/vcase/sample/CaptureCases.kt | 70 +++++++++++++++ .../kotlin/dev/vcase/sample/SampleTheme.kt | 22 ++++- .../dev/vcase/sample/RecordVerifyTest.kt | 31 ++++++- .../dev/vcase/sample/SampleVCaseHost.kt | 15 +++- samples/compose-desktop/vcase.manifest.json | 50 +++++++++++ .../src/commonMain/kotlin/dev/vcase/VCase.kt | 17 ++++ .../commonMain/kotlin/dev/vcase/VCaseAxes.kt | 16 ++++ .../kotlin/dev/vcase/VCasePointerTest.kt | 8 ++ .../vcase/compose/desktop/DesktopRenderer.kt | 66 ++++++++++++-- .../dev/vcase/compose/desktop/VCaseHost.kt | 19 +++- .../dev/vcase/compose/desktop/VCaseScanner.kt | 11 +++ .../vcase/compose/desktop/RunVCasesTest.kt | 88 ++++++++++++++++++- .../compose/desktop/cases/CaptureCases.kt | 85 ++++++++++++++++++ .../src/main/kotlin/dev/vcase/core/Axes.kt | 2 +- .../main/kotlin/dev/vcase/core/Manifest.kt | 30 +++++++ .../kotlin/dev/vcase/core/ManifestDiff.kt | 1 + .../dev/vcase/core/ManifestValidation.kt | 17 ++++ .../kotlin/dev/vcase/core/CaseCaptureTest.kt | 69 +++++++++++++++ 22 files changed, 683 insertions(+), 27 deletions(-) create mode 100644 samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt create mode 100644 vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/cases/CaptureCases.kt create mode 100644 vcase-core/src/test/kotlin/dev/vcase/core/CaseCaptureTest.kt diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8b26c6c..40d4e65 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -4,6 +4,8 @@ on: push: branches: [main] pull_request: + # Run on a branch without opening a pull request. + workflow_dispatch: permissions: contents: read diff --git a/README.md b/README.md index f8b5f8b..c104ac8 100644 --- a/README.md +++ b/README.md @@ -93,6 +93,52 @@ Optional hooks: Inside a case, `LocalVCaseVariant.current` gives the axes and the fixture name. +### Per-case capture settings + +A case can change how it is captured. Every setting is optional, defaults to the host's +behaviour, and is written to the manifest's `capture` object only when set, so existing +cases, manifests and goldens are unchanged. + +| `@VCase` parameter | default | effect | +|---|---|---| +| `maxWidth` | `0` (host's bound, by default the viewport width) | width bound in dp of a component capture, for content wider than the host allows (a wide gallery) | +| `maxHeight` | `0` (host's bound, by default 4x the viewport height) | height bound in dp of a component capture | +| `settleFrames` | `-1` (host's `settleFrames`) | frames rendered before the captured one, e.g. `2` for a popup that lays itself out a frame late | +| `frameIntervalMs` | `-1` (host's `frameTimeNanos`) | frame `i` renders at `i * frameIntervalMs` ms; `0` renders every frame at time 0 | + +```kotlin +@VCase("ds.choice-list.gallery", maxWidth = 1600) // wider than the 1200dp gallery bound +@VCase("ds.tooltip.open", settleFrames = 2, frameIntervalMs = 0) // popup settled, animations not started +@VCase("ds.toast.shown", settleFrames = 20, frameIntervalMs = 16) // a 300 ms fade-in has finished +``` + +- `maxWidth` / `maxHeight` replace the bounds of the host's `CaptureSize.WrapContent`. A + screen is captured at its viewport, so the manifest check rejects them on screens. +- `settleFrames` applies to the capture pass. The measure pass of a component (which finds + its content size) keeps the host's count. +- `settleFrames = N, frameIntervalMs = 0` matches a hand-written + `repeat(N) { scene.render() }; scene.render()` on an `ImageComposeScene`: state, effects + and popups settle, while time-driven animations stay at their start. Give a positive + interval to let animations run. + +### Wide layouts and the mouse + +The pointer axis (`touch`, `fine`) is how a case asks for mouse sizing: +`pointer = ["fine"]`, or `["touch", "fine"]` for both. A wide layout (a desktop type scale, +larger panes) is a viewport with a size class: + +```kotlin +ManifestViewport("wide", 1200, 2400, 2f, optIn = true, sizeClass = VCaseSizeClass.WIDE) + +@VCase("ds.desktop-scale.gallery", viewport = ["wide"], pointer = ["fine", "touch"]) +``` + +The host reads `variant.axes.viewport.sizeClass` and `variant.axes.pointer` in `Wrap` and +pins the theme's layout and input modes with them. It should not derive them from the +capture size: a component is captured at its content size, which says nothing about the +window it was designed for. `sizeClass` is free text (`VCaseSizeClass.COMPACT` and `WIDE` are +the conventional names). It is not an axis of its own, so it never appears in file names. + ### 3. Add one test class ```kotlin @@ -164,10 +210,10 @@ export default function Variants() { return ; } | module | what | |---|---| -| `vcase-annotations` | `@VCase`, `@VCaseDivergence`, `VCaseKind`, axis model (`VCaseAxis`, `VCasePointer`, `VCaseViewport`, `VCaseAxisValues`). KMP, no dependencies. | -| `vcase-core` | JVM. Manifest model + JSON (`VCaseManifest`, `VCaseJson`), `ManifestValidation`, `VCaseIds`, `AxisExpansion` / `VCaseVariant`, `ManifestDiff`, `ImageCompare` / `PixelTolerance` / `RegionTolerance`, `CaptureMeta`, `GoldenStore` / `GoldenRun` / `RunSummary`, `HtmlReport`. | +| `vcase-annotations` | `@VCase`, `@VCaseDivergence`, `VCaseKind`, axis model (`VCaseAxis`, `VCasePointer`, `VCaseViewport`, `VCaseSizeClass`, `VCaseAxisValues`). KMP, no dependencies. | +| `vcase-core` | JVM. Manifest model + JSON (`VCaseManifest`, `ManifestCapture`, `VCaseJson`), `ManifestValidation`, `VCaseIds`, `AxisExpansion` / `VCaseVariant`, `ManifestDiff`, `ImageCompare` / `PixelTolerance` / `RegionTolerance`, `CaptureMeta`, `GoldenStore` / `GoldenRun` / `RunSummary`, `HtmlReport`. | | `vcase-compose-desktop` | JVM, Compose Desktop. `VCaseScanner` (ComposablePreviewScanner `JvmAnnotationScanner` + ClassGraph), `VCaseHost`, `CaptureSize`, `LocalVCaseVariant`, `DesktopRenderer` (ImageComposeScene, renderer `desktop-skiko`), `runVCases`, `VCaseDesktopConfig`, `VCaseDesktopTest`. | -| `samples/compose-desktop` | Four cases, a host, the one test class, committed goldens. | +| `samples/compose-desktop` | Seven cases (including a wide capture, a settled popup and a wide size class with both pointers), a host, the one test class, committed goldens. | ## Building diff --git a/docs/design.md b/docs/design.md index 1fc7654..825d5e2 100644 --- a/docs/design.md +++ b/docs/design.md @@ -113,6 +113,11 @@ Phase 1 additions to `vcase/1` (all optional, omitted from the JSON while unset) - `cases[].formerly`: previous ids. - `cases[].needsDevice`: the case can only be rendered on a device or emulator. - `divergences[].expires`: an ISO date. +- `viewport[].sizeClass`: the layout mode the host pins for the viewport (`compact`, `wide`). + It is not an axis and is not part of file names. +- `cases[].capture`: per-case capture settings, each optional: `maxWidth` / `maxHeight` + (dp bounds of a component capture), `settleFrames` (frames before the captured one) and + `frameIntervalMs` (frame `i` at `i * frameIntervalMs` ms; 0 = every frame at time 0). ### Id rules **[built]** @@ -165,7 +170,9 @@ fun ChannelMembersCase(data: MembersFixture) { `ScreenshotTimeContext`) and pinned fonts. The project injects its own theme and these freeze settings through a `VCaseHost` interface. The framework does not know about Raft. **[built]** Frames render at fixed times (`frameTimeNanos`), and density and font - scale come from the axes. + scale come from the axes. A case can override the frame plan (`settleFrames`, + `frameIntervalMs`) and the content-size bounds (`maxWidth`, `maxHeight`); the host maps + the viewport's `sizeClass` and the pointer axis to the theme's layout and input modes. - The data parameter's type follows from the fixture name. The adapter deserializes the generated JSON into it (kotlinx.serialization). **[planned]** In phase 1 cases have no parameters. A case with a parameter is reported as an error. The fixture name is diff --git a/docs/pilot-raft-mobile.md b/docs/pilot-raft-mobile.md index 3acd7e9..8c05fe2 100644 --- a/docs/pilot-raft-mobile.md +++ b/docs/pilot-raft-mobile.md @@ -103,7 +103,35 @@ tasks, and the legacy golden directory. harness does. Making `locale` a real axis changes the type styles, so it needs a re-record. - **Tests with interaction** (hover, pointer density, pull-down, toast timing) need more host hooks: settle frames per case, `LocalRaftSpinnerStillStep`, input injection. These - tests come last. + tests come last. Per-case settle frames, wide captures and the wide / mouse modes now + exist (see below); input injection does not. + +## Capture settings the remaining galleries need + +After batch 2, the remaining `RaftScreenshot` tests use three `capture` parameters that the +first host could not express. Each maps to a vcase setting: + +| `RaftScreenshot.capture(...)` | `@VCase` | legacy tests | +|---|---|---| +| `maxWidthDp = 1340 / 1400 / 1600` | `maxWidth = 1340 / 1400 / 1600` | ThemeDecor (`top_actions`), ChoicePicker, ChoiceList, Combobox (`sheet`) | +| `settleFrames = N` | `settleFrames = N, frameIntervalMs = 0` | AppRail, DisplayComponent, FrameInsets, InteractiveComponent, MessageReaction, MobileNavServer, PointerDensity, PreviewCard, SideActionColumn, SidebarSectionMouse, ThemeDecor, ToastHost, TopBar | +| `scale = RaftScale.Wide` | `viewport = ["wide"]` | DesktopScale, FitToolbar (`members_fine`), PointerDensity | +| `pointerInput = RaftPointerInput.Fine` | `pointer = ["fine"]` (`["fine", "touch"]` for both) | DesktopScale, FitToolbar (`members_fine`), PointerDensity, SidebarSectionMouse | + +Pixel parity notes: + +- `RaftScreenshot` renders every frame with `scene.render()`, that is at time 0, and measures + the content with one frame. `settleFrames = N, frameIntervalMs = 0` does the same: the + capture pass renders N + 1 frames at time 0, and the measure pass keeps the host's count + (0 for `RaftVCaseHost`, one frame). Without `frameIntervalMs = 0` the frames would step + 16 ms and animations would move. +- The host needs a `wide` viewport with the same bounds as `compact`: + `ManifestViewport("wide", 1200, 2400, 2f, optIn = true, sizeClass = VCaseSizeClass.WIDE)`, + and `Wrap` picks `RaftScale.Wide` from `variant.axes.viewport.sizeClass` (Compact + otherwise). Its golden names end in `,wide,fine` / `,wide,touch`. +- `maxWidth` replaces the host's `CaptureSize.WrapContent(1200, 2400)` width only; the + 2400 dp height bound stays. + - **Source line numbers in the manifest.** Editing above a case changes its `source` line, and the manifest check then asks for a `vcase.mode=scan`. This is by design (the manifest must equal the scan), but it is a real cost in review noise. diff --git a/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt b/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt new file mode 100644 index 0000000..c7db2a2 --- /dev/null +++ b/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt @@ -0,0 +1,70 @@ +package dev.vcase.sample + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicText +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.dp +import androidx.compose.ui.window.Popup +import dev.vcase.VCase + +// Cases that change how they are captured, not only what they show. + +/** + * Wider than the 360dp phone viewport, which bounds a component by default: `maxWidth` lets + * the capture grow to the content instead of cutting it at 360dp. + */ +@VCase("ds.toolbar.wide", maxWidth = 720) +@Composable +fun WideToolbarCase() { + Row(Modifier.width(600.dp), horizontalArrangement = Arrangement.SpaceBetween) { + listOf("Bold", "Italic", "Link", "Quote", "Code", "List").forEach { SampleButton(it, ButtonKind.Secondary) } + } +} + +/** + * A tooltip open under its button. A popup lays itself out a frame after its anchor, so the + * capture waits two settle frames; at time 0 each, so a fade-in would not have started + * (`frameIntervalMs = 0`). + */ +@VCase("ds.tooltip.open", settleFrames = 2, frameIntervalMs = 0) +@Composable +fun TooltipOpenCase() { + Box(Modifier.width(180.dp).height(100.dp)) { + SampleButton("Save") + Popup(offset = IntOffset(0, 112)) { + val c = SampleTheme.colors + Box( + Modifier + .background(c.text, RoundedCornerShape(6.dp)) + .border(1.dp, c.border, RoundedCornerShape(6.dp)) + .padding(horizontal = 8.dp, vertical = 4.dp), + ) { + BasicText("Save changes (Ctrl+S)", style = SampleTheme.body.copy(color = c.canvas)) + } + } + } +} + +/** + * The buttons on a desktop-width window: the `desktop` viewport's size class is `wide`, so + * the host pins the wide type scale; with a mouse (`fine`) the buttons are shorter than with + * a finger. + */ +@VCase("ds.button.desktop", viewport = ["desktop"], pointer = ["fine", "touch"]) +@Composable +fun DesktopButtonsCase() { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + SampleButton("Cancel", ButtonKind.Secondary) + SampleButton("Save") + } +} diff --git a/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/SampleTheme.kt b/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/SampleTheme.kt index df3f6e1..76a00f9 100644 --- a/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/SampleTheme.kt +++ b/samples/compose-desktop/src/main/kotlin/dev/vcase/sample/SampleTheme.kt @@ -11,7 +11,7 @@ import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.platform.Font import androidx.compose.ui.unit.sp -/** A tiny design system: two palettes, one font, a touch / fine pointer switch. */ +/** A tiny design system: two palettes, one font, a touch / fine pointer switch, a compact / wide scale. */ @Immutable data class SampleColors( val canvas: Color, @@ -50,8 +50,12 @@ val DarkColors = enum class SamplePointer { Touch, Fine } +/** The layout mode an app picks from its window width: wide windows get a larger type scale. */ +enum class SampleScale { Compact, Wide } + val LocalSampleColors = staticCompositionLocalOf { LightColors } val LocalSamplePointer = staticCompositionLocalOf { SamplePointer.Touch } +val LocalSampleScale = staticCompositionLocalOf { SampleScale.Compact } object SampleFonts { private fun bytes(name: String): ByteArray = @@ -72,20 +76,32 @@ object SampleFonts { object SampleTheme { val colors: SampleColors @Composable get() = LocalSampleColors.current val pointer: SamplePointer @Composable get() = LocalSamplePointer.current + val scale: SampleScale @Composable get() = LocalSampleScale.current - val body: TextStyle @Composable get() = TextStyle(fontFamily = SampleFonts.family, fontSize = 14.sp, color = colors.text) - val title: TextStyle @Composable get() = TextStyle(fontFamily = SampleFonts.family, fontSize = 18.sp, fontWeight = FontWeight.Bold, color = colors.text) + val body: TextStyle + @Composable get() = + TextStyle(fontFamily = SampleFonts.family, fontSize = if (scale == SampleScale.Wide) 16.sp else 14.sp, color = colors.text) + val title: TextStyle + @Composable get() = + TextStyle( + fontFamily = SampleFonts.family, + fontSize = if (scale == SampleScale.Wide) 22.sp else 18.sp, + fontWeight = FontWeight.Bold, + color = colors.text, + ) } @Composable fun SampleTheme( dark: Boolean, pointer: SamplePointer = SamplePointer.Touch, + scale: SampleScale = SampleScale.Compact, content: @Composable () -> Unit, ) { CompositionLocalProvider( LocalSampleColors provides if (dark) DarkColors else LightColors, LocalSamplePointer provides pointer, + LocalSampleScale provides scale, content = content, ) } diff --git a/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/RecordVerifyTest.kt b/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/RecordVerifyTest.kt index bec8d85..063050f 100644 --- a/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/RecordVerifyTest.kt +++ b/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/RecordVerifyTest.kt @@ -29,7 +29,9 @@ class RecordVerifyTest { assertTrue(recorded.ok, recorded.describe()) val stems = recorded.summary!!.results.map { it.variant.fileStem }.toSet() // 4 button (2 themes x 2 pointers) + 2 badge + 4 card (2 themes x 2 font scales) + 4 screen (2 x 2 viewports) - assertEquals(14, stems.size, stems.toString()) + // + 2 wide toolbar + 2 tooltip + 4 desktop button (2 themes x 2 pointers) + assertEquals(22, stems.size, stems.toString()) + assertTrue("ds.button.desktop@dark,desktop,fine" in stems) assertTrue("ds.button.variants@dark,phone,fine" in stems) assertTrue("ds.card.default@light,phone,fs1.3" in stems) assertTrue("screen.inbox.empty@dark,wide" in stems) @@ -73,4 +75,31 @@ class RecordVerifyTest { val badge = ImageIO.read(File(dir, "ds.badge.counts@light,phone.png")) assertTrue(badge.width < 400 && badge.height < 200, "${badge.width}x${badge.height}") } + + @Test + fun captureSettings() { + val root = kotlin.io.path.createTempDirectory("vcase-sample").toFile() + val r = + runVCases( + SampleVCaseHost, + VCaseDesktopConfig( + packages = listOf("dev.vcase.sample"), + mode = VCaseMode.Record, + goldensDir = File(root, "g"), + outputDir = File(root, "o"), + manifestFile = null, + filter = listOf("ds.toolbar.wide", "ds.button.desktop"), + ), + ) + assertTrue(r.ok, r.describe()) + val dir = File(root, "g/desktop-skiko") + // maxWidth = 720: 600dp of toolbar + 2 x 16dp of canvas, past the 360dp phone bound. + val toolbar = ImageIO.read(File(dir, "ds.toolbar.wide@light,phone.png")) + assertEquals(1264, toolbar.width) + assertTrue(r.summary!!.results.all { it.meta!!.warnings.isEmpty() }, r.summary!!.results.map { it.meta!!.warnings }.toString()) + // With a mouse the controls are shorter than with a finger. + val desktop = ImageIO.read(File(dir, "ds.button.desktop@light,desktop,fine.png")) + val desktopTouch = ImageIO.read(File(dir, "ds.button.desktop@light,desktop,touch.png")) + assertTrue(desktopTouch.height > desktop.height, "touch ${desktopTouch.height} vs fine ${desktop.height}") + } } diff --git a/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/SampleVCaseHost.kt b/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/SampleVCaseHost.kt index 266b461..2df6104 100644 --- a/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/SampleVCaseHost.kt +++ b/samples/compose-desktop/src/test/kotlin/dev/vcase/sample/SampleVCaseHost.kt @@ -7,6 +7,7 @@ import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp import dev.vcase.VCasePointer +import dev.vcase.VCaseSizeClass import dev.vcase.compose.desktop.VCaseHost import dev.vcase.core.ManifestCase import dev.vcase.core.ManifestDefaults @@ -22,8 +23,14 @@ object SampleVCaseHost : VCaseHost { override val defaults = ManifestDefaults( theme = listOf("light", "dark"), - // `wide` is opt-in: only cases that list it (screens) are captured at it. - viewport = listOf(ManifestViewport("phone", 360, 640, 2f), ManifestViewport("wide", 960, 600, 1f, optIn = true)), + // `wide` and `desktop` are opt-in: only cases that list them are captured at them. + // `desktop` declares the wide size class, which the host maps to the wide type scale. + viewport = + listOf( + ManifestViewport("phone", 360, 640, 2f), + ManifestViewport("wide", 960, 600, 1f, optIn = true), + ManifestViewport("desktop", 1280, 800, 2f, optIn = true, sizeClass = VCaseSizeClass.WIDE), + ), locale = listOf("en"), pointer = listOf("touch"), ) @@ -52,7 +59,9 @@ object SampleVCaseHost : VCaseHost { content: @Composable () -> Unit, ) { val pointer = if (variant.axes.pointer == VCasePointer.Fine) SamplePointer.Fine else SamplePointer.Touch - SampleTheme(dark = variant.axes.theme == "dark", pointer = pointer) { + // The layout mode comes from the viewport's size class, never from the capture size. + val scale = if (variant.axes.viewport.sizeClass == VCaseSizeClass.WIDE) SampleScale.Wide else SampleScale.Compact + SampleTheme(dark = variant.axes.theme == "dark", pointer = pointer, scale = scale) { if (variant.case.kind == ManifestCase.KIND_SCREEN) { content() } else { diff --git a/samples/compose-desktop/vcase.manifest.json b/samples/compose-desktop/vcase.manifest.json index 4ec17d5..849a47e 100644 --- a/samples/compose-desktop/vcase.manifest.json +++ b/samples/compose-desktop/vcase.manifest.json @@ -19,6 +19,14 @@ "h": 600, "density": 1.0, "optIn": true + }, + { + "name": "desktop", + "w": 1280, + "h": 800, + "density": 2.0, + "optIn": true, + "sizeClass": "wide" } ], "locale": [ @@ -38,6 +46,23 @@ "parity": [], "divergences": [] }, + { + "id": "ds.button.desktop", + "kind": "component", + "source": "samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt:65", + "fixture": null, + "axes": { + "viewport": [ + "desktop" + ], + "pointer": [ + "fine", + "touch" + ] + }, + "parity": [], + "divergences": [] + }, { "id": "ds.button.variants", "kind": "component", @@ -68,6 +93,31 @@ "parity": [], "divergences": [] }, + { + "id": "ds.toolbar.wide", + "kind": "component", + "source": "samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt:28", + "fixture": null, + "axes": {}, + "parity": [], + "divergences": [], + "capture": { + "maxWidth": 720 + } + }, + { + "id": "ds.tooltip.open", + "kind": "component", + "source": "samples/compose-desktop/src/main/kotlin/dev/vcase/sample/CaptureCases.kt:41", + "fixture": null, + "axes": {}, + "parity": [], + "divergences": [], + "capture": { + "settleFrames": 2, + "frameIntervalMs": 0 + } + }, { "id": "screen.inbox.empty", "kind": "screen", diff --git a/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCase.kt b/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCase.kt index 6f6fa1f..6ac8325 100644 --- a/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCase.kt +++ b/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCase.kt @@ -35,6 +35,19 @@ package dev.vcase * @property divergences decided differences from other platforms. * @property needsDevice the case can only be rendered on a device or emulator * (gestures, keyboard, system sheets); JVM adapters skip it. + * @property maxWidth bound in dp of a [VCaseKind.Component] capture's width, for content wider + * than the host's bound (a wide gallery); `0` = the host's bound (by default the viewport + * width). Content reaching the bound is cut there and gets a warning. + * @property maxHeight bound in dp of a [VCaseKind.Component] capture's height; `0` = the + * host's bound (by default 4x the viewport height). + * @property settleFrames frames rendered before the captured one, e.g. `2` for a popup or + * tooltip that lays itself out a frame late; `-1` = the host's `settleFrames`. Applies to the + * capture pass; a component's size is measured as the host measures it. + * @property frameIntervalMs fixed time step between rendered frames: frame `i` renders at + * `i * frameIntervalMs` ms. `0` renders every frame at time 0, so state settles but + * animations never start (what `ImageComposeScene.render()` with no time does); a positive + * step lets time-driven animations run, e.g. `settleFrames = 20, frameIntervalMs = 16` for + * a 300 ms fade. `-1` = the host's `frameTimeNanos`. */ @MustBeDocumented @Target(AnnotationTarget.FUNCTION) @@ -52,6 +65,10 @@ public annotation class VCase( val formerly: Array = [], val divergences: Array = [], val needsDevice: Boolean = false, + val maxWidth: Int = 0, + val maxHeight: Int = 0, + val settleFrames: Int = -1, + val frameIntervalMs: Int = -1, ) /** What a case captures; decides the capture size. */ diff --git a/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCaseAxes.kt b/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCaseAxes.kt index 9d31f9e..a0248d1 100644 --- a/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCaseAxes.kt +++ b/vcase-annotations/src/commonMain/kotlin/dev/vcase/VCaseAxes.kt @@ -20,6 +20,16 @@ public object VCaseTheme { public const val DARK: String = "dark" } +/** + * Conventional viewport size classes ([VCaseViewport.sizeClass]): the layout mode an app picks + * from its window width (phone vs desktop type scale, control sizes). Projects may use any + * other names (e.g. Material's `compact` / `medium` / `expanded`). + */ +public object VCaseSizeClass { + public const val COMPACT: String = "compact" + public const val WIDE: String = "wide" +} + /** Pointer axis values: a finger (large targets, no hover) or a mouse / trackpad. */ public enum class VCasePointer(public val value: String) { Touch("touch"), @@ -35,12 +45,18 @@ public enum class VCasePointer(public val value: String) { /** * A named viewport: logical size in dp ([width] x [height]) and pixel [density] * (1dp = density px). Declared once in the project defaults, referenced by [name]. + * + * [sizeClass] is the layout mode the host should pin for this viewport (e.g. + * [VCaseSizeClass.WIDE]), or null when the project does not declare one. It lets a host + * render the wide layout without deriving it from the capture size: a component is captured + * at its content size, which says nothing about the window it is designed for. */ public data class VCaseViewport( val name: String, val width: Int, val height: Int, val density: Float, + val sizeClass: String? = null, ) /** One concrete point of the axis space a case is rendered at. */ diff --git a/vcase-annotations/src/commonTest/kotlin/dev/vcase/VCasePointerTest.kt b/vcase-annotations/src/commonTest/kotlin/dev/vcase/VCasePointerTest.kt index deac2c9..93ccd00 100644 --- a/vcase-annotations/src/commonTest/kotlin/dev/vcase/VCasePointerTest.kt +++ b/vcase-annotations/src/commonTest/kotlin/dev/vcase/VCasePointerTest.kt @@ -17,3 +17,11 @@ class VCasePointerTest { assertEquals(listOf("theme", "viewport"), VCaseAxis.ORDER.take(2)) } } + +class VCaseViewportTest { + @Test + fun sizeClassIsOptional() { + assertEquals(null, VCaseViewport("phone", 390, 844, 3f).sizeClass) + assertEquals(VCaseSizeClass.WIDE, VCaseViewport("desktop", 1280, 800, 2f, VCaseSizeClass.WIDE).sizeClass) + } +} diff --git a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/DesktopRenderer.kt b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/DesktopRenderer.kt index 5286d06..c905c58 100644 --- a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/DesktopRenderer.kt +++ b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/DesktopRenderer.kt @@ -65,8 +65,9 @@ public object DesktopRenderer { Box(modifier) { host.Wrap(variant) { content() } } } } + val frames = Frames.of(host, variant) val size = - when (val policy = host.captureSize(variant)) { + when (val policy = Frames.captureSize(host, variant)) { CaptureSize.Viewport -> IntSize(px(vp.width, vp.density), px(vp.height, vp.density)) is CaptureSize.WrapContent -> { val maxW = px(policy.maxWidthDp ?: vp.width, vp.density) @@ -77,7 +78,7 @@ public object DesktopRenderer { Box(Modifier.wrapContentSize(Alignment.TopStart, unbounded = false)) { framed(Modifier.onSizeChanged { measured = it }) } - }.use { scene -> renderFrames(host, scene) } + }.use { scene -> frames.render(scene, frames.measureSettle) } check(measured.width > 0 && measured.height > 0) { "${variant.fileStem} rendered nothing" } if (measured.width >= maxW) warnings += "content reaches the max width ($maxW px)" if (measured.height >= maxH) warnings += "content reaches the max height ($maxH px)" @@ -88,17 +89,64 @@ public object DesktopRenderer { return ImageComposeScene(width = size.width, height = size.height, density = density) { framed(Modifier) }.use { scene -> - val image = renderFrames(host, scene) + val image = frames.render(scene, frames.captureSettle) image.encodeToData(EncodedImageFormat.PNG)?.bytes ?: error("PNG encode failed for ${variant.fileStem}") } } - private fun renderFrames( - host: VCaseHost, - scene: ImageComposeScene, - ): org.jetbrains.skia.Image { - repeat(host.settleFrames) { scene.render(host.frameTimeNanos(it)) } - return scene.render(host.frameTimeNanos(host.settleFrames)) + /** + * Frame plan of one variant. The measure pass (pass 1 of a wrap-content capture) renders the + * host's [VCaseHost.settleFrames]; the capture pass renders the case's `settleFrames` when it + * sets one, else the host's. Frame times come from the case's `frameIntervalMs` when it sets + * one, else from [VCaseHost.frameTimeNanos]. A case that sets neither renders exactly as + * before per-case settings existed. + */ + internal class Frames( + val measureSettle: Int, + val captureSettle: Int, + private val time: (Int) -> Long, + ) { + /** Frame times of a pass with [settle] settle frames: the settle frames, then the captured one. */ + fun times(settle: Int): List = (0..settle).map(time) + + fun render( + scene: ImageComposeScene, + settle: Int, + ): org.jetbrains.skia.Image { + repeat(settle) { scene.render(time(it)) } + return scene.render(time(settle)) + } + + companion object { + fun of( + host: VCaseHost, + variant: VCaseVariant, + ): Frames { + val capture = variant.case.capture + return Frames( + measureSettle = host.settleFrames, + captureSettle = capture?.settleFrames ?: host.settleFrames, + time = { i -> capture?.frameTimeNanos(i) ?: host.frameTimeNanos(i) }, + ) + } + + /** The host's policy with the case's `maxWidth` / `maxHeight` in place of its bounds. */ + fun captureSize( + host: VCaseHost, + variant: VCaseVariant, + ): CaptureSize { + val policy = host.captureSize(variant) + val capture = variant.case.capture ?: return policy + return when (policy) { + CaptureSize.Viewport -> policy + is CaptureSize.WrapContent -> + policy.copy( + maxWidthDp = capture.maxWidth ?: policy.maxWidthDp, + maxHeightDp = capture.maxHeight ?: policy.maxHeightDp, + ) + } + } + } } private fun px( diff --git a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseHost.kt b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseHost.kt index 534fd6a..3945ba3 100644 --- a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseHost.kt +++ b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseHost.kt @@ -24,19 +24,28 @@ public interface VCaseHost { /** Renderer id, also the golden subdirectory. Change it when the rendering stack changes. */ public val renderer: String get() = RENDERER - /** Frames rendered before the captured one (popups lay themselves out a frame late). */ + /** + * Frames rendered before the captured one (popups lay themselves out a frame late). A case's + * `@VCase(settleFrames = ...)` replaces it for that case's capture pass; the measure pass of + * a wrap-content capture always renders this many. + */ public val settleFrames: Int get() = 0 /** * Frame time of frame [index] (0 = first). Every frame time is fixed, so animations and * `withFrameNanos` clocks are deterministic; the default steps 16 ms per frame from 0. + * A case's `@VCase(frameIntervalMs = ...)` replaces it for that case. */ public fun frameTimeNanos(index: Int): Long = index * 16_000_000L /** Hash of the fonts the host loads, written to capture metadata; null if not tracked. */ public val fontsHash: String? get() = null - /** How big the capture is; default: components at content size, screens at the viewport. */ + /** + * How big the capture is; default: components at content size, screens at the viewport. + * A case's `@VCase(maxWidth = ..., maxHeight = ...)` replaces the [CaptureSize.WrapContent] + * bounds returned here. + */ public fun captureSize(variant: VCaseVariant): CaptureSize = if (variant.case.kind == ManifestCase.KIND_SCREEN) CaptureSize.Viewport else CaptureSize.WrapContent() @@ -46,7 +55,11 @@ public interface VCaseHost { /** Called after rendering a variant (also after a failure). */ public fun afterCapture(variant: VCaseVariant) {} - /** Wraps every case: theme for the axis values, background, freeze settings. */ + /** + * Wraps every case: theme for the axis values, background, freeze settings. Pin the + * layout mode from `variant.axes.viewport.sizeClass` (e.g. a wide type scale) and the input + * mode from `variant.axes.pointer`, not from the capture size. + */ @Composable public fun Wrap( variant: VCaseVariant, diff --git a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseScanner.kt b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseScanner.kt index 6ebf2e6..551d996 100644 --- a/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseScanner.kt +++ b/vcase-compose-desktop/src/main/kotlin/dev/vcase/compose/desktop/VCaseScanner.kt @@ -5,6 +5,7 @@ import dev.vcase.VCase import dev.vcase.VCaseAxis import dev.vcase.VCaseKind import dev.vcase.core.AxisExpansion +import dev.vcase.core.ManifestCapture import dev.vcase.core.ManifestCase import dev.vcase.core.ManifestDefaults import dev.vcase.core.ManifestDivergence @@ -101,9 +102,19 @@ public object VCaseScanner { }, formerly = a.formerly.toList(), needsDevice = a.needsDevice, + capture = captureOf(a), ) } + /** The annotation's capture settings; its "use the host's" sentinels (0, -1) become null. */ + internal fun captureOf(a: VCase): ManifestCapture? = + ManifestCapture( + maxWidth = a.maxWidth.takeIf { it != 0 }, + maxHeight = a.maxHeight.takeIf { it != 0 }, + settleFrames = a.settleFrames.takeIf { it != -1 }, + frameIntervalMs = a.frameIntervalMs.takeIf { it != -1 }, + ).takeUnless { it.isEmpty } + private fun annotationOf(p: ComposablePreview): VCase { val cls = Class.forName(p.declaringClass, false, Thread.currentThread().contextClassLoader ?: VCase::class.java.classLoader) return cls.declaredMethods.firstNotNullOfOrNull { m -> m.takeIf { it.name == p.methodName }?.getAnnotation(VCase::class.java) } diff --git a/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/RunVCasesTest.kt b/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/RunVCasesTest.kt index 64dc2c4..1bde5e7 100644 --- a/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/RunVCasesTest.kt +++ b/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/RunVCasesTest.kt @@ -5,7 +5,10 @@ import androidx.compose.foundation.layout.Box import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color +import dev.vcase.core.AxisExpansion import dev.vcase.core.ImageCompare +import dev.vcase.core.ManifestCapture +import dev.vcase.core.ManifestCase import dev.vcase.core.ManifestDefaults import dev.vcase.core.ManifestViewport import dev.vcase.core.VCaseJson @@ -25,7 +28,7 @@ object TestHost : VCaseHost { override val defaults = ManifestDefaults( theme = listOf("light", "dark"), - viewport = listOf(ManifestViewport("tiny", 20, 12, 2f)), + viewport = listOf(ManifestViewport("tiny", 20, 12, 2f), ManifestViewport("tiny-wide", 20, 12, 2f, optIn = true, sizeClass = "wide")), locale = listOf("en"), pointer = listOf("touch"), ) @@ -45,7 +48,21 @@ class RunVCasesTest { @Test fun scanFindsCustomAnnotationIncludingPrivateFunctions() { val cases = VCaseScanner.scan(pkg, "src/test/kotlin") - assertEquals(listOf("test.device.only", "test.screen.full", "test.square.plain", "test.square.pointer"), cases.map { it.entry.id }) + assertEquals( + listOf( + "test.bar.bounded", + "test.bar.wide", + "test.device.only", + "test.frames.clock", + "test.frames.first", + "test.frames.still", + "test.screen.full", + "test.square.plain", + "test.square.pointer", + "test.square.size-class", + ), + cases.map { it.entry.id }, + ) val plain = cases.first { it.entry.id == "test.square.plain" }.entry assertTrue(plain.source.startsWith("src/test/kotlin/dev/vcase/compose/desktop/cases/TestCases.kt:"), plain.source) assertEquals(listOf("web:test.square.plain"), plain.parity) @@ -102,6 +119,73 @@ class RunVCasesTest { assertTrue(File(root, "out/report/index.html").readText().contains("test.square.plain@dark,tiny")) } + @Test + fun scanReadsCaptureSettings() { + val cases = VCaseScanner.scan(pkg).associate { it.entry.id to it.entry } + assertEquals(null, cases.getValue("test.square.plain").capture) + assertEquals(null, cases.getValue("test.frames.first").capture) + assertEquals(ManifestCapture(maxWidth = 40), cases.getValue("test.bar.wide").capture) + assertEquals(ManifestCapture(settleFrames = 3, frameIntervalMs = 0), cases.getValue("test.frames.still").capture) + assertEquals(ManifestCapture(settleFrames = 3, frameIntervalMs = 100), cases.getValue("test.frames.clock").capture) + } + + @Test + fun framePlan() { + val defaults = TestHost.defaults + fun variant(capture: ManifestCapture?) = AxisExpansion.expand(ManifestCase(id = "ds.a.b", source = "x", capture = capture), defaults).first() + // Nothing set: the host's frames, as before. + val plain = DesktopRenderer.Frames.of(TestHost, variant(null)) + assertEquals(listOf(0L), plain.times(plain.captureSettle)) + val still = DesktopRenderer.Frames.of(TestHost, variant(ManifestCapture(settleFrames = 2, frameIntervalMs = 0))) + assertEquals(0, still.measureSettle) + assertEquals(listOf(0L, 0L, 0L), still.times(still.captureSettle)) + val stepped = DesktopRenderer.Frames.of(TestHost, variant(ManifestCapture(settleFrames = 2))) + assertEquals(listOf(0L, 16_000_000L, 32_000_000L), stepped.times(stepped.captureSettle)) + // The case's bounds replace the host's; unset ones keep it. + assertEquals(CaptureSize.WrapContent(1600, null), DesktopRenderer.Frames.captureSize(TestHost, variant(ManifestCapture(maxWidth = 1600)))) + assertEquals(CaptureSize.WrapContent(), DesktopRenderer.Frames.captureSize(TestHost, variant(null))) + } + + @Test + fun captureSettingsRender() { + val root = kotlin.io.path.createTempDirectory("vcase-desktop").toFile() + val r = + runVCases( + TestHost, + VCaseDesktopConfig( + packages = pkg, + mode = VCaseMode.Record, + goldensDir = File(root, "g"), + outputDir = File(root, "o"), + manifestFile = null, + filter = listOf("test.bar.*", "test.frames.*", "test.square.size-class"), + ), + ) + assertTrue(r.ok, r.describe()) + val dir = File(root, "g/desktop-skiko") + fun png(stem: String) = ImageIO.read(File(dir, "$stem.png")) + + // maxWidth: the whole 30dp bar; without it the capture stops at the 20dp viewport. + assertEquals(60 to 4, png("test.bar.wide@light,tiny").let { it.width to it.height }) + assertEquals(40, png("test.bar.bounded@light,tiny").width) + val warned = r.summary!!.results.first { it.variant.fileStem == "test.bar.bounded@light,tiny" }.meta!!.warnings + assertTrue(warned.any { "max width" in it }, warned.toString()) + + val red = 0xFFFF0000.toInt() + val blue = 0xFF0000FF.toInt() + fun probe(stem: String) = png(stem).let { it.getRGB(1, 1) to it.getRGB(5, 1) } + // One frame at time 0: neither square has seen frames. + assertEquals(red to red, probe("test.frames.first@light,tiny")) + // Three settle frames at time 0: frames arrived, the clock stayed at 0. + assertEquals(blue to red, probe("test.frames.still@light,tiny")) + // Three settle frames 100 ms apart: the clock moved. + assertEquals(blue to blue, probe("test.frames.clock@light,tiny")) + + // The size class reaches the case; the pointer axis names the file. + assertEquals(6, png("test.square.size-class@light,tiny,fine").width) + assertEquals(12, png("test.square.size-class@light,tiny-wide,fine").width) + } + @Test fun manifestDriftFailsVerify() { val root = kotlin.io.path.createTempDirectory("vcase-desktop").toFile() diff --git a/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/cases/CaptureCases.kt b/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/cases/CaptureCases.kt new file mode 100644 index 0000000..cce3d02 --- /dev/null +++ b/vcase-compose-desktop/src/test/kotlin/dev/vcase/compose/desktop/cases/CaptureCases.kt @@ -0,0 +1,85 @@ +package dev.vcase.compose.desktop.cases + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.size +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.runtime.withFrameNanos +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import dev.vcase.VCase +import dev.vcase.VCaseSizeClass +import dev.vcase.compose.desktop.LocalVCaseVariant + +// Cases for the per-case capture settings: a bound wider than the viewport, settle frames and +// the frame clock, and a viewport size class. + +/** 30dp wide: more than the 20dp `tiny` viewport, inside its own 40dp bound. */ +@VCase("test.bar.wide", theme = ["light"], maxWidth = 40) +@Composable +fun WideBar() { + Box(Modifier.size(30.dp, 2.dp).background(Color.Red)) +} + +/** The same bar on the default bound: cut at the viewport width. */ +@VCase("test.bar.bounded", theme = ["light"]) +@Composable +fun BoundedBar() { + Box(Modifier.size(30.dp, 2.dp).background(Color.Red)) +} + +/** + * Two 2dp squares: the left one turns blue once two frames have reached the content, the right + * one once a frame at 100 ms or later has. + */ +@Composable +private fun FrameProbe() { + var frames by remember { mutableIntStateOf(0) } + var lastNanos by remember { mutableLongStateOf(0L) } + LaunchedEffect(Unit) { + while (true) { + withFrameNanos { + frames++ + lastNanos = it + } + } + } + Row { + Box(Modifier.size(2.dp).background(if (frames >= 2) Color.Blue else Color.Red)) + Box(Modifier.size(2.dp).background(if (lastNanos >= 100_000_000L) Color.Blue else Color.Red)) + } +} + +@VCase("test.frames.first", theme = ["light"]) +@Composable +fun FramesFirst() { + FrameProbe() +} + +@VCase("test.frames.still", theme = ["light"], settleFrames = 3, frameIntervalMs = 0) +@Composable +fun FramesStill() { + FrameProbe() +} + +@VCase("test.frames.clock", theme = ["light"], settleFrames = 3, frameIntervalMs = 100) +@Composable +fun FramesClock() { + FrameProbe() +} + +/** 6dp on a wide viewport, 3dp otherwise. */ +@VCase("test.square.size-class", theme = ["light"], viewport = ["tiny", "tiny-wide"], pointer = ["fine"]) +@Composable +fun SizeClassSquare() { + val wide = LocalVCaseVariant.current?.axes?.viewport?.sizeClass == VCaseSizeClass.WIDE + Box(Modifier.size(if (wide) 6.dp else 3.dp).background(Color.Blue)) +} diff --git a/vcase-core/src/main/kotlin/dev/vcase/core/Axes.kt b/vcase-core/src/main/kotlin/dev/vcase/core/Axes.kt index 89cf566..254c9f8 100644 --- a/vcase-core/src/main/kotlin/dev/vcase/core/Axes.kt +++ b/vcase-core/src/main/kotlin/dev/vcase/core/Axes.kt @@ -55,7 +55,7 @@ public object AxisExpansion { val viewports = (case.axes[VCaseAxis.VIEWPORT] ?: defaults.defaultViewports().map { it.name }).map { name -> val v = defaults.viewport(name) ?: throw IllegalArgumentException("${case.id}: unknown viewport '$name'") - VCaseViewport(v.name, v.w, v.h, v.density) + VCaseViewport(v.name, v.w, v.h, v.density, v.sizeClass) } val locales = case.axes[VCaseAxis.LOCALE] ?: defaults.locale val pointers = diff --git a/vcase-core/src/main/kotlin/dev/vcase/core/Manifest.kt b/vcase-core/src/main/kotlin/dev/vcase/core/Manifest.kt index 579f2b9..8a9b980 100644 --- a/vcase-core/src/main/kotlin/dev/vcase/core/Manifest.kt +++ b/vcase-core/src/main/kotlin/dev/vcase/core/Manifest.kt @@ -51,6 +51,10 @@ public data class ManifestDefaults( * the default expansion unless [optIn] is set: then only cases that name it use it * (e.g. `wide` for screens only). [optIn] is an addition to the design-doc schema and is * omitted from the JSON while false. + * + * [sizeClass] is the layout mode the host pins for this viewport (`compact`, `wide`, ...; + * see `VCaseSizeClass`), handed to the host as `variant.axes.viewport.sizeClass`. Omitted + * from the JSON while null. */ @OptIn(ExperimentalSerializationApi::class) @Serializable @@ -60,6 +64,7 @@ public data class ManifestViewport( val h: Int, val density: Float, @EncodeDefault(EncodeDefault.Mode.NEVER) val optIn: Boolean = false, + @EncodeDefault(EncodeDefault.Mode.NEVER) val sizeClass: String? = null, ) @OptIn(ExperimentalSerializationApi::class) @@ -77,6 +82,8 @@ public data class ManifestCase( val divergences: List = emptyList(), @EncodeDefault(EncodeDefault.Mode.NEVER) val formerly: List = emptyList(), @EncodeDefault(EncodeDefault.Mode.NEVER) val needsDevice: Boolean = false, + /** Per-case capture settings; omitted from the JSON while the case uses the host's. */ + @EncodeDefault(EncodeDefault.Mode.NEVER) val capture: ManifestCapture? = null, ) { public companion object { public const val KIND_COMPONENT: String = "component" @@ -84,6 +91,29 @@ public data class ManifestCase( } } +/** + * How one case is captured, where it differs from the host. Every field is optional (null = + * the host's value) and omitted from the JSON while null; a case that sets none has no + * `capture` object at all. + */ +@OptIn(ExperimentalSerializationApi::class) +@Serializable +public data class ManifestCapture( + /** Bound in dp of a component capture's width (content wider than the host's bound). */ + @EncodeDefault(EncodeDefault.Mode.NEVER) val maxWidth: Int? = null, + /** Bound in dp of a component capture's height. */ + @EncodeDefault(EncodeDefault.Mode.NEVER) val maxHeight: Int? = null, + /** Frames rendered before the captured one. */ + @EncodeDefault(EncodeDefault.Mode.NEVER) val settleFrames: Int? = null, + /** Frame `i` renders at `i * frameIntervalMs` ms; 0 = every frame at time 0. */ + @EncodeDefault(EncodeDefault.Mode.NEVER) val frameIntervalMs: Int? = null, +) { + public val isEmpty: Boolean get() = maxWidth == null && maxHeight == null && settleFrames == null && frameIntervalMs == null + + /** Frame time of frame [index] in nanoseconds, or null when the host decides. */ + public fun frameTimeNanos(index: Int): Long? = frameIntervalMs?.let { index.toLong() * it * 1_000_000L } +} + @OptIn(ExperimentalSerializationApi::class) @Serializable public data class ManifestDivergence( diff --git a/vcase-core/src/main/kotlin/dev/vcase/core/ManifestDiff.kt b/vcase-core/src/main/kotlin/dev/vcase/core/ManifestDiff.kt index 8cbec06..665ff54 100644 --- a/vcase-core/src/main/kotlin/dev/vcase/core/ManifestDiff.kt +++ b/vcase-core/src/main/kotlin/dev/vcase/core/ManifestDiff.kt @@ -64,6 +64,7 @@ public data class ManifestDiff( if (a.divergences != b.divergences) add("divergences") if (a.formerly != b.formerly) add("formerly") if (a.needsDevice != b.needsDevice) add("needsDevice") + if (a.capture != b.capture) add("capture") } if (fields.isNotEmpty()) { changed[id] = fields diff --git a/vcase-core/src/main/kotlin/dev/vcase/core/ManifestValidation.kt b/vcase-core/src/main/kotlin/dev/vcase/core/ManifestValidation.kt index 9087d41..6ce1823 100644 --- a/vcase-core/src/main/kotlin/dev/vcase/core/ManifestValidation.kt +++ b/vcase-core/src/main/kotlin/dev/vcase/core/ManifestValidation.kt @@ -13,6 +13,7 @@ public object ManifestValidation { if (d.pointer.isEmpty()) out += "defaults.pointer is empty" d.viewport.groupBy { it.name }.filterValues { it.size > 1 }.keys.forEach { out += "viewport '$it' declared twice" } d.viewport.filter { it.w <= 0 || it.h <= 0 || it.density <= 0f }.forEach { out += "viewport '${it.name}' must have positive w, h, density" } + d.viewport.filter { it.sizeClass != null && it.sizeClass.isBlank() }.forEach { out += "viewport '${it.name}': sizeClass is blank (omit it instead)" } manifest.cases.groupBy { it.id }.filterValues { it.size > 1 }.forEach { (id, list) -> out += "id '$id' declared ${list.size} times: ${list.joinToString { it.source }}" @@ -34,11 +35,27 @@ public object ManifestValidation { } if (dv.why.isBlank()) out += "${case.id}: divergence with '${dv.with}' needs a why" } + case.capture?.let { out += captureProblems(case, it) } runCatching { AxisExpansion.expand(case, d) }.onFailure { out += it.message ?: it.toString() } } return out } + private fun captureProblems( + case: ManifestCase, + c: ManifestCapture, + ): List = + buildList { + if (c.isEmpty) add("${case.id}: capture is empty (omit it instead)") + c.maxWidth?.let { if (it <= 0) add("${case.id}: capture.maxWidth must be positive, is $it") } + c.maxHeight?.let { if (it <= 0) add("${case.id}: capture.maxHeight must be positive, is $it") } + c.settleFrames?.let { if (it < 0) add("${case.id}: capture.settleFrames must be 0 or more, is $it") } + c.frameIntervalMs?.let { if (it < 0) add("${case.id}: capture.frameIntervalMs must be 0 or more, is $it") } + if (case.kind == ManifestCase.KIND_SCREEN && (c.maxWidth != null || c.maxHeight != null)) { + add("${case.id}: maxWidth / maxHeight bound a component's content size; a screen is captured at its viewport") + } + } + public fun requireValid(manifest: VCaseManifest) { val problems = problems(manifest) require(problems.isEmpty()) { "invalid vcase manifest:\n" + problems.joinToString("\n") { " - $it" } } diff --git a/vcase-core/src/test/kotlin/dev/vcase/core/CaseCaptureTest.kt b/vcase-core/src/test/kotlin/dev/vcase/core/CaseCaptureTest.kt new file mode 100644 index 0000000..9b05c0e --- /dev/null +++ b/vcase-core/src/test/kotlin/dev/vcase/core/CaseCaptureTest.kt @@ -0,0 +1,69 @@ +package dev.vcase.core + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +/** Per-case capture settings (`capture`) and viewport size classes: optional, absent while unset. */ +class CaseCaptureTest { + private val wide = ManifestViewport("wide", 1200, 2400, 2f, optIn = true, sizeClass = "wide") + private val defaults = DEFAULTS.copy(viewport = DEFAULTS.viewport + wide) + + @Test + fun unsetSettingsAreNotWritten() { + val text = VCaseJson.encode(VCaseManifest(project = "p", defaults = DEFAULTS, cases = listOf(case("ds.a.b")))) + assertFalse("capture" in text, text) + assertFalse("sizeClass" in text, text) + } + + @Test + fun captureAndSizeClassRoundTrip() { + val c = case("ds.a.b", mapOf("viewport" to listOf("wide"))).copy(capture = ManifestCapture(maxWidth = 1600, settleFrames = 2, frameIntervalMs = 0)) + val m = VCaseManifest(project = "p", defaults = defaults, cases = listOf(c)) + val text = VCaseJson.encode(m) + assertTrue("\"sizeClass\": \"wide\"" in text, text) + assertTrue("\"maxWidth\": 1600" in text && "\"settleFrames\": 2" in text && "\"frameIntervalMs\": 0" in text, text) + assertFalse("maxHeight" in text, text) + assertEquals(m, VCaseJson.decodeManifest(text)) + assertTrue(ManifestValidation.problems(m).isEmpty(), ManifestValidation.problems(m).toString()) + } + + @Test + fun sizeClassReachesTheVariant() { + val v = AxisExpansion.expand(case("ds.a.b", mapOf("viewport" to listOf("phone", "wide"))), defaults) + assertEquals(listOf(null, "wide"), v.filter { it.axes.theme == "light" }.map { it.axes.viewport.sizeClass }) + // The size class is not an axis of its own: names and metadata are unchanged. + assertEquals(listOf("light,phone", "light,wide", "dark,phone", "dark,wide"), v.map { it.name }) + assertFalse("sizeClass" in v[1].axisMap()) + } + + @Test + fun frameTimes() { + assertEquals(listOf(0L, 0L, 0L), (0..2).map { ManifestCapture(frameIntervalMs = 0).frameTimeNanos(it) }) + assertEquals(listOf(0L, 16_000_000L, 32_000_000L), (0..2).map { ManifestCapture(frameIntervalMs = 16).frameTimeNanos(it) }) + assertEquals(null, ManifestCapture(settleFrames = 2).frameTimeNanos(1)) + } + + @Test + fun validationOfCaptureSettings() { + fun problems(vararg cases: ManifestCase) = ManifestValidation.problems(VCaseManifest(project = "p", defaults = defaults, cases = cases.toList())) + assertEquals(1, problems(case("ds.a.b").copy(capture = ManifestCapture())).size) + assertEquals(1, problems(case("ds.a.b").copy(capture = ManifestCapture(maxWidth = 0))).size) + assertEquals(1, problems(case("ds.a.b").copy(capture = ManifestCapture(maxHeight = -5))).size) + assertEquals(1, problems(case("ds.a.b").copy(capture = ManifestCapture(settleFrames = -1))).size) + assertEquals(1, problems(case("ds.a.b").copy(capture = ManifestCapture(frameIntervalMs = -1))).size) + assertEquals(1, problems(case("screen.a.b").copy(kind = ManifestCase.KIND_SCREEN, capture = ManifestCapture(maxWidth = 1600))).size) + assertTrue(problems(case("screen.a.b").copy(kind = ManifestCase.KIND_SCREEN, capture = ManifestCapture(settleFrames = 2))).isEmpty()) + val blank = ManifestValidation.problems(VCaseManifest(project = "p", defaults = DEFAULTS.copy(viewport = DEFAULTS.viewport + wide.copy(sizeClass = " ")), cases = emptyList())) + assertEquals(1, blank.size, blank.toString()) + } + + @Test + fun changedCaptureIsAManifestChange() { + val a = VCaseManifest(project = "p", defaults = DEFAULTS, cases = listOf(case("ds.a.b"))) + val b = a.copy(cases = listOf(case("ds.a.b").copy(capture = ManifestCapture(settleFrames = 2)))) + assertEquals(mapOf("ds.a.b" to listOf("capture")), ManifestDiff.between(a, b).changed) + assertEquals(listOf("defaults"), ManifestDiff.between(a, a.copy(defaults = defaults)).header) + } +} From 2939b5b4b7b110076a8a73f0322ed43e6ecc6274 Mon Sep 17 00:00:00 2001 From: sindresorhus Date: Sat, 21 Nov 2026 06:08:56 +0000 Subject: [PATCH 2/2] test(sample): goldens for the three capture-settings cases (recorded on CI run 44873920166) Signed-off-by: sindresorhus --- .../ds.button.desktop@dark,desktop,fine.png | Bin 0 -> 7466 bytes .../ds.button.desktop@dark,desktop,touch.png | Bin 0 -> 7630 bytes .../ds.button.desktop@light,desktop,fine.png | Bin 0 -> 7199 bytes .../ds.button.desktop@light,desktop,touch.png | Bin 0 -> 7362 bytes .../ds.toolbar.wide@dark,phone.png | Bin 0 -> 11434 bytes .../ds.toolbar.wide@light,phone.png | Bin 0 -> 11308 bytes .../ds.tooltip.open@dark,phone.png | Bin 0 -> 12275 bytes .../ds.tooltip.open@light,phone.png | Bin 0 -> 12065 bytes 8 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,fine.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,touch.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@light,desktop,fine.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@light,desktop,touch.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@dark,phone.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@light,phone.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@dark,phone.png create mode 100644 samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@light,phone.png diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,fine.png b/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,fine.png new file mode 100644 index 0000000000000000000000000000000000000000..7efa3000220c62c3e7ff14fe2df76ec7549da2c6 GIT binary patch literal 7466 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 THb?`*PmrRVn(QxWv(Wzmt+$Sf literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,touch.png b/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@dark,desktop,touch.png new file mode 100644 index 0000000000000000000000000000000000000000..e5de4e8a9e6243a46ee0058cbe0d83edb0e009bd GIT binary patch literal 7630 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 L5cx{5Y0&=wKvKR# literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@light,desktop,fine.png b/samples/compose-desktop/goldens/desktop-skiko/ds.button.desktop@light,desktop,fine.png new file mode 100644 index 0000000000000000000000000000000000000000..14a87519a38d56fda9876d31748909b82e43d273 GIT binary patch literal 7199 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 CJ3e#( literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@dark,phone.png b/samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@dark,phone.png new file mode 100644 index 0000000000000000000000000000000000000000..d90e3d4203a8e6675c65e607539b6d276a6ef0fe GIT binary patch literal 11434 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 DBs=r1 literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@light,phone.png b/samples/compose-desktop/goldens/desktop-skiko/ds.toolbar.wide@light,phone.png new file mode 100644 index 0000000000000000000000000000000000000000..9f48bc00fa88f96c73f64e80e6dde5c1d77c2417 GIT binary patch literal 11308 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 literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@dark,phone.png b/samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@dark,phone.png new file mode 100644 index 0000000000000000000000000000000000000000..c3a9d13d17a45a894c6eb83bd57311243aed6188 GIT binary patch literal 12275 zcmd6N^;=ZYyDx%*N{dK?f{3()AUP;Vmmno2NJtFbt+WV;v@n2lcQb%=cQbUu&>h2Y z7vFP#xc|UC=gjlWGY`Y;z4l(~eLuB!u(F~Q{zJ-#7#JA%GSU(%7#Mf5!TbJwZ1By) z!p|Jwk^HA6*i6W}Q94&d?nP6YTCp(XB5YJYv27?mPLI zd0xSX_h)Z(9njNh#~T8Ik7*oIbHxY#Dq7^ln3J*#JbRS){N1AxdiqC?N{z13(z|uT zcu}<+2VSDI1uLJ<)*FhR?;$Vs=8^7N@cMdLB4T2$_)n5#PwDAZDDFiC1;zcwl$DT> zm$}18PoJ6Y^N5&ORYfc~D2SOkMM9!A>aj9Cy`k*Gm*6nQ|M8!1hjJ_!-gTgrsT-8a zK~7-`Noj0vQURsylk5`N-b;E*mGUTb0E4HaOyhiQ{281>nGS5HK zQo(%k@+z6U@UHC3S-P0t^Jj9lwp@+Z)=xe_6f&!`|1HqJUorpE?NjP(XS#9&O?R5j zY*b?V@Kl#ww)-^N(HSO8J20%p{~^x1eW6=o#oVygCs!NdW1v*f)HI|P?+`7-pZ)OA zUQ-bHLXl?P!agd&fA(c%btJw_~m;WBYqRf0DVM{h!Ni8XfY38Em$S!rcBedPAa-yB~`XSqq;K z36D}Fx;`#PMP09}*NKW)CtErQ(A$x|dM_qW=Q_l(Vt_d7&ib=H<2lW-VqIPBN~IYZ zq=PR{tjs@ilCwk00;?!A{_F>nzR5RBCg96ZUg2=gr~d>br1 zhDZ2PNJvU-BDs)p{0p&=5R)$}F)lFf57*1Afzzl9q1mv|oEVs@@5)U$#*E5z=oz2G|4@Y3PE;}iCm!3=Ss zF1+=+ZKx}>%+y{WK1O2ZRBd~@)Q|K?Zy`*|WQl5UWTW)GggM*2$I2=y??yTGF$a&< zOgHBCh}oWmKpTA1c&v6OhFYt5c4<$h%1xd`SU@sz^k1D4gkh_5(5u+zMBe=s>G>l{ zTnK;{wK7Lyzj2A?1`#)=Pa2N19ryJhX@RQ5%BNJG?9zptZDed;h7}kQ58NQ|;~&t1Zg4MyB5D{wgb4ko#XZs4~}@=n$J+ZCqBk8UwVDQ+lSje)K$<7FOTxf*L(Ag zg!u}ix*vh#E+lo@fo?`m>YuaQJ;T~_i^NtyOplulr?L_#7E({qDY$KU!6_^Aj~&Yf z5}!LEt1x&irs`4fkxjoMbkJl0tL2FK1hn;Ut26(g2 z1gp{=HK*~>`kQ5Hf#T>;h=*8zJl?cZ4NVa?d&y|-lQp0a2wrmJ2V_3JY_qjW~% znLX>fC)FX-wD=frV6KT!s`V0f6ze!ga_@czq-Ch<9)@Y`w8MrI4x)M8{yB4Pw~wsi z^g|!-z&kFZ7KRCWHhkd~Jxr10Wl4%6l8?xRej{HNNMde|Ab% zs+jRBIl;fpFg#KY$`+H$iMXzGC3bg4i+!##IIj1^>*uI|9wjEueqBQNg9`a=XT#L@ z30rldEC<@qrV=88&`{C*B~{1a%K}{snR^vm9#!wKcSAmhe+?aRw$|#d3_aQy-}~S; ze<{36J2yEMP3t~6C8V5XCH|>=Q+zz<)cqb57uBEA zKh(+}WDxGrJLD@Q5LF!C8h0WQd$No5b+B9nS~nvp)}d`<-&oju*-+3@T;`l^d!!hx zhqSeE$kghwx?O7%NxK@?&_B+pPP393eI6Z=`{v4`Vx>x^s5$sLnPr0BN6pUNja7`h zC-A&(3wftgg1b&s%}G#J>7QDG-V69-*B3!SIx-KlA>i~WT0NitRN!TH_%I1LF5PER zS(Xu~jsz8RZrmnhIr}O+A)rz5NPV`u06CWO-v9FjgQ*4~#>4)#n1tPpm3MUUCzmF4H_+RTVyNR@riU&03|{e&7pQWL0`t{kAV7 zdxs1_f;$$j2o}XbmwbXZgTV&6@^Yp#H z|Kya#SxAuUCg)?Klb*(4^oiVew^_MxDk-&^#5`@?cb5=F6G`q8ZH-?whs!K^sqSfQEvQJ0?j%$sU@!4y&0mG8PVy&mQV@2DJ@`-Ss z;UU%G?`=Ok<0nWEL-bc^2zE;x2e_(XN5Sf`pn~&~=UapVi9}G`mlj8QSB2s>%ogo;F|-zv2_LF^nmc*Q?D~hSy|bI#5IvdJ_AyVv#&wU%i|c-iZd!Zm4u8EB|_#D z7Z+3Ou7ULQ?W$tYufxZzhhuo+b0lsq8Nr;YaU{f)hVKyTV}bigfx5BR4bRzM)MPQU zuw^^UGRPnX++m%05s*+%!KptN`F-w%74=_dgtMCuolZ~hViRJ09#Nu;bnVxgttlNy zG#dF6pRdIoaa}@{Tkuw*70-e0v2ss;Qf*S-RNWEI@5svEw!#mjOr5uPU^&L7N(N0@ zrHYxqirv{EoCy+or_9rL@zX8#a4h)`1qEwtKkMIR8u<+bQ)}5Z? zY9#Ytzok@6N?xcGC~4MF!;;a|l&9fX?l*y^*D)(=iO;%c z$ZPGylvI%6Ib7`#h$HH1SKEtpD!(+TPN8)kS+ZZC-izaC*{D4x}_{C`#QMlNE}n#t=H z8}^>7vZXtAJNCpm0gHFkK1S(Z`nPS!uE>@|-BbNw&@hw{6ckKBt899t=&P7g$UN@p z$#+xU6de>455A@7FqCUley7XBW^CF6{`kr9{y&0IcCw~(<5BBV+Yd)SIo|%)S2Oj$ zfBzm%Glxlxd8|AAl>VV>Y{X1&XcvI<(Ex20woAxgi&xVe_S`ZBi1H0?iPlyi4t*R$ zlKe`;JOo2>r`TeK%d#DDC8>0O1jQvXW3n(I$#G6mnwJW}?{Z(T2&^wK*iKZfm}F7t zL=dW0tb1a4HH3NZo~y@^*GqrXvQQ2=i9*cG2QPiLdyQf|xqtm$GQ?;5fE5)L1;f`) z$<7X99J#XPTTlNlJ-@WGV_bXmSZV@UjjXZJL5@}_unv8d)(HJw3NxP7&r+f_IOs(` zWFoG4nTeOJ@4mAu0aCMteb^z&i{-(Cgy=2$7TiaS?VRmy{+wksz_6#O)~t>uEf?k10-< z7N&tqO|6q-ydK2eqsb^{yQuZ>p0(H1Ox<@kjS33z7L6SY@0XimaC@?(9EunRrd0xMS5i_U54$Aj2+P1E zA{q>cX4Rn7jrl82qU?Efy0|f9gke=<{4`Bc!Bg|0VBqC2VY7F)32xd>%}BD}1%hGl@v3y$J~FG+tj=5R;aEnWYG$7Zpv) z&zDDCU&|;e^40Q+$E7CJR8^5hy+(?hPJX#9dBf}uTKAuqC&(57Z@QxQ0XR{yv1AV( z9B8sVX%D9hPfJT1Vhj!<@1B~9w_R?(Q|!E_w>5FbSNmKXxG)+aCyW%`I;ZoiD=Of& zgP6;$=acxLpRfl1il+>%k~i=Bl$wuZh7K`;RHD0LE@W!oN6-siE|&pHDjm)TmBnHa zxt@mGPVD=14-DX>hzAl##)5c)Wt=A)g|e`hplQMC?rv#m*?0tuXB(of++M=K;O|fd zIWWo~-mv5Ne-n)52f?GCb8>Pd-oGa%B~`FH`~Zi;U62LLlCf$G+tU>Z6Z+n;7YctK z5e@zr9He#FAj)pS=18L?Q)XsnMqMJYE3IZ_Ra72zbuph`TnwlB)6Ld8rYR-Q={V0i zO2)dX$ta4-&Np0ROqMZWrQY$_+m7Whe-5bOHVSD<7Dv*GtX=sR+j*jm8_wO5X^+GTq9D@=~ zOQa?n5eZ387>y7!jRQ*jowztTzZDx;9#oHceavXK&!(R{b^fh@+F6$=_>V%qXpb}{kgvArJD{U#j>Xq`i+i$ z)bsYFhg_FuHp9=)?|PwK*)bR-@zyh9+douU>0)4FVFd?IwRJ@@O_ec)y$^X(X16N4 zTZ^P^K-m%e{rgMD@yNyZnAS?BqBJPK|K6G zzmFf6T;x(_t@k2P)bo;Dx3bf?%5uu?37e)ga{Lbb27Pt+?nhC-Nif#M)x7?5Zth1) zN=lO9Uf)4Aj27*M!eBHM6co1zGF1lo()MGov%i0>{%o$TuW#o^V^*WAmzOAKJ#W(f zzRh$cv_+gyM7qjq_TZS!^VL=`iJ63y^>W#OsOeB@n~{mhA^K`>ab@MMSiz@?{o~{3 zZ24p&ZhpfJp6+w5>ohOqUHpq0lfq*sDuf1+tI7xb0Rt8&RGpEr3V)pH8qE8XEBEyw+V~ zZ{~04?-LSc$wapI{&^jesgMwru(!J#R%E@o`VEK9<5#lRr$*1RuzStWv|8dWVdFW76Y_b`!_6{ zqOYLRDnN1Co$njCoo>s7)BaWCh>eJ7>Y($+`&VttsZM1C`UQa62nL%T-0$}zRpI4w z6|giOhh3J2U%qgDy=ZN{#+Y$J6p%J=>WGT=)$BD~-I**kmW%G0LLhhyTkm72=bz7w zCXbD!NG84=%RO=L|HL+CT9}o^#I9ZWoQo@hgh_F*)=|vgn470evuurt&k98cfNy1G zWw_Q6161CO8?vBsy*G#W zSjf#ccy7+sYgbfgudc04hduvdXjoiT#qjFYFZA`5{cwk3Y7h|N^_9L-kzRdnzQOrEF<_d=u{@1ivf{Ix{I@j*DfPT^va_@Mil{vH#G`fz z*%5rJc6f9Ia^TN9(~hleZ4oe-0&*O>F)Q>_+p30wpP%0gb-+q@rv$7ntHX(mF5IyqJvb`J)@Xi*sI_g@q;%|CrLadaU=u(laxMiw#h~5OqK}<}HIvyDiMxUpRaX>!*3-$AJ=$Nfv;=D-`vHeNKA130ygt32g)G{;_ zk?gJ4GXN3*jqR(=xV zpOx(OBRl)$oYxg}cw~fJ@R$G-6U8d>!{eZh3j}T=BCz#j?{BTG5|W{A->>!>!zDv0 z@7QclasejzEnweZ)a<8mv6WX-nWjw`F8GsL;5%m{ia#PELJfNq5UcVy-W1%G2XQsHRA^eG`o1$`{wF3Sl<*Vf)5mM41gbM8X5ujQ#Nqr z@`-PP2Sl&FS3(h7F8e7g^8-If=gYnh8H%FzJ>AZB#bJUK%r9R)6&3vksLXh^I~snu zh3rid$!lJB0L0NAe#5l5xCpLbDc&?G6IA7Bp>6^Y8>f5o1I_*+ae^nhm&cpB#`vH> zz}BT+X|VoL}oyGvRG=ob|262I2?D z$M6(Kjx1Ucw^uIvPXUC7eMn0(JlOV&U+a9=)TA zbV(gw%=-^E`{Azk5Ag99j|SFlu6BIMxs6_`W+{Fd%cYZ+l}*jg&Yp&{X`iwO2M6DZ zEHwIz%yRMWAQ%~7o-2?|lNA{AP3#F0Q(b3tMt>ahCl*j%& zp05QkFGiaa6uR@gC!r6}FGF?C)(HI2u&}V>-C2awLNO3@=JNx9Kzlprl-4T|R%wc` z;j;SSvXV;qBosDqPas41zOk|K5Xqra{R<#dtiSx@Od~()(s_LKHp8Hl6)}p*@r;BsrO`C)Qg|MMb3|xufPGF0N&=)QPOOBq#4V znuSp0m?#{A-bj9!<%>f&oU0~Qb3^NOPK>eE57RK11KL~FfQo>CKtAzYZ~$^c&Bayc zdOEd!pJ2D$en4aZAX?CmA4{V-y|Q}sZdO(qrWyC{O{_gFij@lmW_w|wus8nbp1$Yn zaHeFB-+*#W2GCLKNmmeTyz2PH7AbD$T^)c9th$ZX^K$@Q?*hrOD?9KM%%mlBIgpT! znZL+>{pl@u1B`$0-~s8li0zVJfh*_p^g5{9+qZXc$zl|}7rtHP3ftQ{IFz5rek#jc zx~5bUuz4DsAt!gU0J%ZgzY!ABsMTo+z`sDuqp^*3PxB7Xm%~3!wN3)jfQ3DCUks3c zjVrLEKySLkkB8;d=32jc)*iNpF0QPpd#+qmHHzr0M&#Gk302MV5&6W$iL9=zuCJGU z{jh0zyX?c4|v|iab8ZoN&E*i9cS%` zub_<1AIhOtXAUVTDNytGLBCwACocojc8hWVziv@3n1tz|jm#d{rz)0XyTh|H$ljOr zf}MeynyJ;yx|$j;hYgzEM1jc8PIl5t5>hocUWmu}z8#D$j8@^<3ln}?T3UISV8Qf6 ze-|?}=3=Kxm+V*zqqT$S-IPMWx&`hYqKY4^CLshe&l0;iS)v+!gz<-;v;LO{=nuP* z*_oM*`5U*(v&M#Q$AS9O=;UO5V;+;U-C0(cm9b~?IFe1hBaDVYRP+u|F0~GuDm#2& zsmWiZKtN%!_SR8fSfy<`}5S7!u+fTKA*D4Evw_QRtA3$5bMcW|Gu zEzG&^Edm=emhIluo8NwKvCba80Sxp8~w%a<>!Q=SFpn})3G9p(P0a`uGRBQ@%No?y4 zQ7Dh`0&OLi^P9#xvqd`7@M6P&5 zua8v$PP|R>Je^{R1=N7N)t&-&&*R%dVv9}sKGC{w6C+Ui-q+DXY00T6DHsq4q}B<) zvVu{Yk&!0*P&5cAQXu6q68NQl$HhtKsb`4z$tIk|EC4+R3Wi0O|IM2?>xPTHWYpcl zM2Ha48kpYmbqG^&sly<*+Zn-^jlpNDf+dehNu!a(&NUX*GaQb|uI}zfTX{vV+>T!w z8X8VjSn%I^9k@&Ij=c*I9>SL!46&Xlapb@WUEsYuS>QvTJ)vF;L(?;YpGzumrPiSc!ISywv1_VdD|B43=)NKO-2@ak0Eh@5( zZp`-{KbtQy0tx~2%E2YFNd1j{MFZOZ?r5@FmDT3cCik;l1|gvXotI2!ob*|xc%_LmlcVc4VQPPLZ zEYrybQGLRuy!S9c+Df1P?ry=o0S_QIq54_>5qx)Er$$OFw`Vx}6akrm8dAjmnMJ zr&JhcbM8tRixOHz`Hd=IwZ6^@`fP7o0{8l9rxavz`C4U_!>&LV{Rj!6cx}$x)HM6X zWVVd5YSJ~E7ySjW-UGCNn%+dpw&YBW{W>Pm<70PgZlq&Kem+}&l8E+Z z?aGQK@m_lc_6P;U;9Oi6~Z(NM0o5JK_?g$7xGZUCs}6RVFV z1Fcw88DM{L9u+2|uB`kokj@LFQ+gRa85uNHp^JP*(rr@QIxNV(SfF{M`yuY9mKn1? zoJ`;)`IDUBpA?3+YN;9~$JZg@0l`}06aeN)mKb{^gHCDS3CM6}E-l~}a zscDC*lE}S(LVNOG<{QpgVrLt@AtPBzfu;R?lFkZ6ikh0_4<1}`RQvi>#I6EbH>A={ z<9`4CeQz>k{*)4*@}qZwI!8E|7(l0}Wx8b>8=HklC6lAG#&83$Fw_vQL=Xa(mX+O7 zG>EhQkthkjb#meZ`Xg1NXuhuc^73-9!SiWXm(<06OL#X7YGe#s14eG$pA2nf@kG$I z^sv%hNJz-4uAp33h}$k?XKhAkk6PV05?D-U8(_bQ=#u{d?Rl}8^}5oX6ATp`HrEXn z4bVLmuxcg?|Fk)_j)0IcJvci0ve^9oC&dwcM1=Mm&r4oLMn*86$w+43PYRwGU_i-5 zJ>E>{&+nyHdOypbm^0};j{{z((ii0Vh9ElV$SZ1S2ReSLutL-NP5n#&A>Hj12{~;W zjb<}}1b`+!UQ2o0Q<%ew(;Chd52Cm{Cm~RXU}?g9eX+_+`V2vluQr!fSI2E^6v!v* z2`))iSw-tt!9N0Sd;09zvs*=qL+kQOzHU4i68dm6S|D zAOEDg;nw%y!tu#UqV#M^(~T48Ey8}iMEO_@WIVT7HvIZj2;|vYb}f^rAzwn#e@6ol z{oTM`kb!FG!~OwWYy)nu9lRw$WCudW;x8SFFWn~*ScEeJFz2vaF$|L2kOb?7VE5gc zx|!30FJbJuwY}qxwbt{wQj9jhdWG`8PyyN3tp`?BiVnM4+tE!fFQ31$nYHauMxPXU z>mJ`bdZ9qcW50$6Y;z=?H!2vsbB0%U>(6N0!#oduw_oLT``p2*-fM7=huky@pD&14 z1C?J1)mBke74SHJ1%&MF{eV!d(y}v+3DExSu;`q>uw0Nz_9s{?R^mJInvZ_PpnPqv zS=g~QS@OkfFhvwZ1(m})I$NR^096J=6Z(KOIYM92fwYir7?_By(F3qd-&z9YiYP!# z^j+JU#-(X*;8Jj`f?g9OJmF_^3GJgfBbp5;ZNx9}Xo@#BPj4iew28Ap|-qkrGKS9?S8EUGl_q$n(7B)A#$n<*+4p;c|bSfQ@7{CN}xLVt%Sf&$W z-~>`0F^v@4yrltmmhchvoK^&3e8Lmfbz%Rbwr=;2k<%fc15<_zvK)e61rMU;^Q%(|NJ=F(5DCf=+)7z_0TK0Zoai617x#CJ`m& zJ7r~4U@yJ_X>+hs#hUw{Jgm6*RSdg!H`t7sEM@!=7f1f+(W8TtlT|>SS=RHSe*P!5 z*`8MQe0F~)n5lTb0`!CTfy^4je+iQfo=i9d)ak|hY@(u~4%?H#v?A{wJlOP_E5o+l zyOd8xM?gD^&d-Ob#VQwnfxb2P^xJ#v2^KUP?C``@<=)4}nC-6BTNyiq|>hi9BLo`x*} zp_C>aPwSkb!$coF9?fY#cH#YjDVvTBj%Dck^ZLtjyA7Xp7;kN&h2n<~#BwoFb3OdP z#ykG5mU#FwLKbY1{`&K2da9{^_b_Z}U&GGX*%Sa9hRac36^HqAhZ^3twzl2`{%}xN z%OJ%rsG2i(kkJrn5t4Z$AP|w9tRyKJu-hBMN)Le~6Eo}z?r{ePXF$L$&NEz5 zFd^qskbwX-X)O%)x4_m#B$##mp};$Otfi%jBxF^A8FH~DE(ec5pTzN+r9#WYKK?qXh^P4p_Jw3fU!De6#fgS;qVBl^QtMdnhbD)%TcTfFpwVs>V_C3htzDGWeOofI1+_S;LCodjmOMLhB z4dsw3yaPCmly*dU1c2QBN~99E!-n#0zy0_@FCY*P2q8@_kL$;eAHcBOdHWV-HandR z5+FgRZOzqJX5Im>Q&`-a_bUE@9X2OkS@{`j2WI-$ifNLew=D?xkGnRCGD|#AEQU?% zIJN=&{P2jC&Z{7k2OjBn(v_FM2VLrn=OYjf2C&N>}8{ z+S=Bqs34sYlYu0Kj~^ccc}gwlaGpwAq8b@TpQ4x~ECXCyS9kYw4vw(nV-m0@wpj{! z{}DVR3c~6*t}g-5jViE3w~w%{yWQ&y2yb&PeCun)#8G(s%|}l!>6S@TQWPa)8R-vW z5e=R~Bbf?ivsa@4E^Y(=jZ!@0Tp!GhsWKcbEv=RHSW(R)vyn`&)hGS=^HY$5G>;q& zTYHfZbA2*5XQ^}E1CCPnc54u%{z!Qa4i13wC1#NUx!k&9AI4wvy(-qt2yb~poRj0> z={Z#|6a)6`(&V`AsbWW|DJv7A^xbF6i0iUOp%I=Z?gWn~PE zjL|^K-|j}o34+J3SEh~6J^$ODUj1MA!1w>Er_a%Jendx;a)^(M;3<9#nfHnkh3`Ip F|34PzazFq8 literal 0 HcmV?d00001 diff --git a/samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@light,phone.png b/samples/compose-desktop/goldens/desktop-skiko/ds.tooltip.open@light,phone.png new file mode 100644 index 0000000000000000000000000000000000000000..a741a0ce20268e7a910eb4f4297d2cb9493624a4 GIT binary patch literal 12065 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