Compose API reference — conventions and scaled module

This document is the authoritative surface-area reference for Jetpack Compose extensions in scaled mode, plus rules that every other strategy (percent, power, fluid, …) mirrors with a different name prefix.

Source of truth: library/src/main/java/com/appdimens/dynamic/compose/.

Not in this file: the resize strategy (com.appdimens.dynamic.compose.resize, code.resize, autoResize*, ResizeBound) — see resize.md and the KDoc tree under KDOC/com.appdimens.dynamic.compose.resize/.

1. Imports

Most Compose extensions live in the top-level package (re-exported from strategy packages):

import com.appdimens.dynamic.compose.sdp
import com.appdimens.dynamic.compose.hdp
import com.appdimens.dynamic.compose.wdp
import com.appdimens.dynamic.compose.ssp
import com.appdimens.dynamic.compose.scaledDp
import com.appdimens.dynamic.compose.scaledSp
import com.appdimens.dynamic.common.DpQualifier
import com.appdimens.dynamic.common.Orientation
import com.appdimens.dynamic.common.UiModeType

Strategy-specific imports (examples):

import com.appdimens.dynamic.compose.percent.psdp
import com.appdimens.dynamic.compose.power.pwsdp

2. Shared behavior (all strategies)

2.1 Flags on `Number` properties

Suffix	Meaning	When to use
(none)	Default scaling for that axis	Normal layouts
`a`	`applyAspectRatio = true`	Non-standard aspect ratios; refined curve
`i`	`ignoreMultiWindows = true`	Split-screen: may return unscaled base when heuristic matches
`ia`	Both `a` and `i`	TV/tablet + multi-window policies together

2.2 `Px` variants

Properties ending in Px return Float in px (layout pixel units for the current density), not Dp. Use for Canvas, legacy interop, or custom Modifier math.

Example: val stroke = 2f.sdpPx

2.3 Orientation inverters (middle of the name)

These swap which Configuration metric is read when orientation matches the inverter rule (see DimenCalculationPlumbing.effectiveQualifier).

Token in name	Typical use
`Ph`	SW-based default → height in portrait
`Lh`	SW-based default → height in landscape
`Pw`	SW-based default → width in portrait
`Lw`	SW-based default → width in landscape
`hdp` + `Lw` / `Pw`	Height axis with PH↔LW / LH↔PW style swaps
`wdp` + `Lh` / `Ph`	Width axis with PW↔LH / LW↔PH style swaps

Note: hdp / wdp blocks expose fewer inverter combinations than sdp by design (see property tables below).

2.4 Low-level composable functions (escape hatch)

fun Number.toDynamicScaledDp(
    qualifier: DpQualifier,
    inverter: Inverter = Inverter.DEFAULT,
    ignoreMultiWindows: Boolean = false,
    applyAspectRatio: Boolean = false,
    customSensitivityK: Float? = null,
): Dp

fun Number.toDynamicScaledPx(...): Float
fun Number.toDynamicScaledSp(...): TextUnit  // also supports fontScale, inverter, etc.

On the View / code side, toDynamicScaledPx and toDynamicScaledDp also have Int and Float overloads with the same parameters (mirroring Number), to avoid boxing on hot paths.

Use when you need a combination that is not exposed as a val shortcut.

3. Strategy prefix map (mirror of scaled)

Replace the bold stem to get the same API shape in another package:

Strategy	Package	Dp stem (SW / H / W)	Sp stem (scaled font)	“Fixed” Sp (no font scale)
scaled	`compose`	`sdp` / `hdp` / `wdp`	`ssp` / `hsp` / `wsp`	`sem` / `hem` / `wem`
percent	`compose.percent`	`psdp` / `phdp` / `pwdp`	`pssp` / `phsp` / `pwsp`	`psem` / `phem` / `pwem`
power	`compose.power`	`pwsdp` / `pwhdp` / `pwwdp`	`pwssp` / `pwhsp` / `pwwsp`	`pwsem` / `pwhem` / `pwwem`
fluid	`compose.fluid`	`fsdp` / `fhdp` / `fwdp`	`fssp` / `fhsp` / `fwsp`	`fsem` / `fhem` / `fwem`
auto	`compose.auto`	`asdp` / `ahdp` / `awdp`	`assp` / `ahsp` / `awsp`	`asem` / `ahem` / `awem`
diagonal	`compose.diagonal`	`dgsdp` / `dghdp` / `dgwdp`	`dgssp` / `dghsp` / `dgwsp`	`dgsem` / `dghem` / `dgwem`
fill	`compose.fill`	`flsdp` / `flhdp` / `flwdp`	`flssp` / `flhsp` / `flwsp`	`flsem` / `flhem` / `flwem`
fit	`compose.fit`	`ftsdp` / `fthdp` / `ftwdp`	`ftssp` / `fthsp` / `ftwsp`	`ftsem` / `fthem` / `ftwem`
interpolated	`compose.interpolated`	`isdp` / `ihdp` / `iwdp`	`issp` / `ihsp` / `iwsp`	`isem` / `ihem` / `iwem`
logarithmic	`compose.logarithmic`	`logsdp` / `loghdp` / `logwdp`	`logssp` / `loghsp` / `logwsp`	`logsem` / `loghem` / `logwem`
perimeter	`compose.perimeter`	`prsdp` / `prhdp` / `prwdp`	`prssp` / `prhsp` / `prwsp`	`prsem` / `prhem` / `prwem`
density	`compose.density`	`dsdp` / `dhdp` / `dwdp`	`dssp` / `dhsp` / `dwsp`	`dsem` / `dhem` / `dwem`

Recommendation: learn scaled first; for other strategies, keep the same suffix pattern (a, i, ia, Px, Ph, …) and only change the prefix column.

Builder classes (Compose + code) use the same prefixed names for terminal accessors (e.g. density builder ends with .dsdp / .dssp / .dsem, not .sdp). On the code module, JVM static entry points live in Dimen{Strategy}Dp objects (e.g. DimenAutoDp.asdp); the custom-dimension builder type is Dimen{Strategy} (e.g. DimenAuto). The scaled strategy keeps DimenScaled and DimenSdp / DimenSsp unchanged.

Source files — code mirrors compose: For each strategy, Kotlin facilitators for Views live in the same Dimen<Strategy>DpExtensions.kt / Dimen<Strategy>SpExtensions.kt filenames as in compose/<strategy>/ (under code/<strategy>/). Scaled uses code/scaled/DimenSdpExtensions.kt and DimenSspExtensions.kt (package com.appdimens.dynamic.code), analogous to compose/scaled/ with package com.appdimens.dynamic.compose.

4. Facilitators — Dp (`DimenSdpExtensions.kt`)

All functions are @Composable. They combine a base value with conditional scaling (rotation, UI mode, sw/h/w thresholds, or both).

Common optional parameters (where present):

finalQualifierResolver: DpQualifier — which axis scales the chosen branch (default matches axis: sdp→SW, hdp→HEIGHT, wdp→WIDTH).
orientation: Orientation — usually LANDSCAPE or PORTRAIT for rotate helpers.
ignoreMultiWindows, applyAspectRatio, customSensitivityK — same meaning as on Number properties.

4.1 Rotation family

Function	Receiver	Returns	What it does	Example
`sdpRotate`	`Int`	`Dp`	Base `Int` as sdp unless `orientation` matches → then `rotationValue` scaled with `finalQualifierResolver`	`80.sdpRotate(50, Orientation.LANDSCAPE)`
`sdpRotatePx`	`Int`	`Float`	Same, px	`80.sdpRotatePx(50)`
`sdpRotate`	`Dp`	`Dp`	Always scales the active branch: uses scaled receiver in default orientation, scaled `rotationValue` when `orientation` matches	`30.dp.sdpRotate(50, orientation = Orientation.LANDSCAPE)`
`sdpRotatePx`	`Dp`	`Float`	px variant	`30.dp.sdpRotatePx(50)`
`sdpRotatePlain`	`Dp`	`Dp`	Plain (`Number` alternate): inactive branch = receiver; active branch scales `rotationValue` (cache + strategy)	`16.sdp.sdpRotatePlain(50)`
`sdpRotatePlain`	`Dp`	`Dp`	Plain (`Dp` alternate): only orientation branch; no extra scaling — receiver and `rotation` must already be strategy values	`30.sdp.sdpRotatePlain(20.sdp)`
`sdpRotatePlainPx`	`Dp`	`Float`	px variant for `Number` alternate	`16.sdp.sdpRotatePlainPx(50)`
`sdpRotatePlainPx`	`Dp`	`Float`	px variant for `Dp` alternate	`30.sdp.sdpRotatePlainPx(20.sdp)`

Repeat the same name pattern for hdpRotate* and wdpRotate* (defaults: finalQualifierResolver = HEIGHT or WIDTH).

4.2 UI mode family (`UiModeType`)

Function	Receiver	Example
`sdpMode` / `sdpModePx`	`Int`	`30.sdpMode(200, UiModeType.TELEVISION)`
`sdpMode` / `sdpModePx`	`Dp`	`30.dp.sdpMode(200, UiModeType.TELEVISION)`
`sdpModePlain` / `sdpModePlainPx`	`Dp`	Two overloads: alternate `Number` (scaled when branch matches) or `Dp` (logic only, no scaling)

Same for hdpMode*, wdpMode*.

4.3 Qualifier threshold family (`DpQualifier` + value)

Function	Receiver	Example
`sdpQualifier` / `sdpQualifierPx`	`Number`	`60.sdpQualifier(120, DpQualifier.SMALL_WIDTH, 600)`
`sdpQualifier` / `sdpQualifierPx` / `sdpQualifierPlain` / `sdpQualifierPlainPx`	`Dp`	`qualifiedValue: Number` or `qualified: Dp` (`qualifierValue` stays the config threshold)

Same for hdpQualifier*, wdpQualifier*.

4.4 Combined screen family (mode + qualifier)

Function	Receiver	Example
`sdpScreen` / `sdpScreenPx`	`Number`	`70.sdpScreen(150, UiModeType.TELEVISION, DpQualifier.SMALL_WIDTH, 600)`
`sdpScreen` / `sdpScreenPx` / `sdpScreenPlain` / `sdpScreenPlainPx`	`Dp`	`screenValue: Number` or `screen: Dp` for Plain (+ same `UiModeType` / qualifier threshold)

Same for hdpScreen*, wdpScreen*.

Nested extensions vs .screen builder: Chained facilitators on Dp / TextUnit (e.g. a.sdpRotatePlain(…).sdpModePlain(…)) follow expression nesting (outside → inside). DimenScaled / scaledDp() .screen(…) entries use priority inside the API, not the same rule as facilitator nesting. Prefer Dp / TextUnit Plain alternates when chaining many facilitators so values are not scaled twice.

Recommendation: wrap the tree with AppDimensProvider when using mode/fold-related UiModeType heavily (see library/PERFORMANCE.md).

Performance: sdpMode / hdpMode / wdpMode and sdpScreen / hdpScreen / wdpScreen (and strategy equivalents) resolve UiModeType via DimenCache.getCachedUiModeType(context), which caches the result per Configuration hash — they do not call SensorManager / WindowMetricsCalculator on every invocation.

4.5 Views / `code` — Plain (`Float` px + `Context`)

Compose logic-only Plain overloads use Dp / TextUnit alternates (no second scaling). On the View side, the same branching is exposed as Float extensions whose receiver and alternate arguments are already in px (layout or text px, depending on use), plus an explicit Context for Configuration / UI-mode cache:

Per strategy: Dimen*PlainPx.kt under com.appdimens.dynamic.code.<strategy> (e.g. DimenScaledPlainPx.kt in code.scaled, DimenPercentPlainPx.kt in code.percent). Naming mirrors Compose: sdpRotatePlainPx, psdpRotatePlainPx, sspRotatePlainPx, etc., for RotatePlain, ModePlain, QualifierPlain, ScreenPlain.
Shared helpers (internal): com.appdimens.dynamic.code.plain — DimenPlainBranch.kt (plainRotatePx, plainModePx, plainQualifierPx, plainScreenPx).

Example (percent / layout px):

import com.appdimens.dynamic.code.percent.psdpRotatePlainPx
import com.appdimens.dynamic.common.Orientation

val a = layoutPx.psdpRotatePlainPx(context, rotationPx, Orientation.LANDSCAPE)

Not covered here: Compose Plain overloads that still re-scale a Number on the active branch — on Views, keep using the existing Number.*Rotate / .*Mode / … functions with Context that already perform full scaling.

5. Facilitators — Sp (`DimenSsp.kt` + `DimenSspExtensions.kt`)

5.1 `Number` rotation (returns `TextUnit`)

Function	Example
`sspRotate`	`16.sspRotate(24, orientation = Orientation.LANDSCAPE)`
`hspRotate`	`16.hspRotate(22)`
`wspRotate`	`16.wspRotate(20)`

Optional: fontScale (default true), ignoreMultiWindows, applyAspectRatio, customSensitivityK.

5.2 `Number` px rotation

Function	Example
`sspRotatePx`	`val px = 16.sspRotatePx(24)`

(hspRotatePx, wspRotatePx same pattern.)

5.3 `TextUnit` rotation / mode / qualifier / screen

For each axis (ssp, hsp, wsp) the module provides composable extensions on TextUnit:

sspRotate, sspRotatePx, sspRotatePlain, sspRotatePlainPx — *RotatePlain / *RotatePlainPx mirror Dp: alternate Number (scaled when active) or TextUnit (logic only).
sspMode, sspModePx, sspModePlain, sspModePlainPx
sspQualifier, sspQualifierPx, sspQualifierPlain, sspQualifierPlainPx
sspScreen, sspScreenPx, sspScreenPlain, sspScreenPlainPx

Examples:

Text("A", fontSize = 16.ssp.sspRotatePlain(24))           // Number alternate (scaled when branch active)
Text("A2", fontSize = 16.ssp.sspRotatePlain(12.ssp))       // TextUnit alternate (no second scaling)
Text("B", fontSize = 16.sspMode(40, UiModeType.TELEVISION))
Text("C", fontSize = 16.ssp.sspQualifier(24, DpQualifier.SMALL_WIDTH, 600))
Text("D", fontSize = 16.ssp.sspScreen(32, UiModeType.TELEVISION, DpQualifier.SMALL_WIDTH, 600))

Number also exposes sspQualifier, sspScreen (+ Px variants) where implemented; sspMode on Number is not present — use TextUnit or property 16.ssp then sspMode on the result, or sspModePx on Number if you need px.

6. Builders — `DimenScaled` / `ScaledSp`

6.1 Entry points

val chain = 16.scaledDp()   // or: 16.dp.scaledDp()
val spChain = 16.scaledSp()

6.2 Fluent configuration

Method	Purpose	Example
`ignoreMultiWindows(Boolean)`	Split-screen heuristic	`.ignoreMultiWindows(true)`
`aspectRatio(Boolean, sensitivityK?)`	AR scaling	`.aspectRatio(true)`

6.3 `screen(...)` overloads (priority order)

Entries are sorted by priority (1 = most specific) and qualifier value (larger sw first).

Priority	Overload idea	Example
1	`UiModeType` + `DpQualifier` + threshold	`.screen(UiModeType.TELEVISION, DpQualifier.SMALL_WIDTH, 600, customValue = 40)`
2	`UiModeType` only	`.screen(UiModeType.TELEVISION, 40)`
3	`DpQualifier` + threshold	`.screen(DpQualifier.SMALL_WIDTH, 600, 24)`
4	`Orientation`	`.screen(Orientation.LANDSCAPE, 12)`

Each overload has variants taking customValue as Dp or Number, and optional finalQualifierResolver, inverter. The Number branch must preserve the same applyAspectRatio and customSensitivityK as the Dp branch (fractional dp values are kept as Float, not truncated to Int).

Physical units (mm / cm / inch) are documented in physical-units.md (unitSizeInDp, radius in dp, code.units conversions).

6.4 Resolution properties (`DimenScaled`)

Property	Result
`.sdp` / `.hdp` / `.wdp`	Final `Dp` on that axis
`.sdpPx` / `.hdpPx` / `.wdpPx`	Final px `Float`

Example:

val pad = 16.scaledDp()
    .aspectRatio(true)
    .ignoreMultiWindows(true)
    .screen(UiModeType.TELEVISION, 40)
    .screen(DpQualifier.SMALL_WIDTH, 600, 24)
    .sdp

6.5 Resolution properties (`ScaledSp`)

Property	Result
`.ssp` / `.hsp` / `.wsp`	`TextUnit`
`.sspPx` / `.hspPx` / `.wspPx`	px `Float`

Appendix A — Complete `Number` property catalog (scaled)

The following tables list every Number extension property in scaled mode. Other strategies use the same names after swapping the prefix (see §3).

A.1 Scaled — `Number` Dp / px properties (`DimenSdp.kt`)

Property	Type	Example
`sdp`	`Dp`	`Modifier.padding(16.sdp)`
`sdpa`	`Dp`	`Modifier.padding(16.sdpa)`
`sdpi`	`Dp`	`Modifier.padding(16.sdpi)`
`sdpia`	`Dp`	`Modifier.padding(16.sdpia)`
`sdpPx`	`Float`	`val px = 16.sdpPx`
`sdpaPx`	`Float`	`val px = 16.sdpaPx`
`sdpiPx`	`Float`	`val px = 16.sdpiPx`
`sdpiaPx`	`Float`	`val px = 16.sdpiaPx`
`sdpPh`	`Dp`	`Modifier.padding(16.sdpPh)`
`sdpPha`	`Dp`	`Modifier.padding(16.sdpPha)`
`sdpPhi`	`Dp`	`Modifier.padding(16.sdpPhi)`
`sdpPhia`	`Dp`	`Modifier.padding(16.sdpPhia)`
`sdpPxPh`	`Float`	`val px = 16.sdpPxPh`
`sdpPxaPh`	`Float`	`val px = 16.sdpPxaPh`
`sdpPxiPh`	`Float`	`val px = 16.sdpPxiPh`
`sdpPxiaPh`	`Float`	`val px = 16.sdpPxiaPh`
`sdpLh`	`Dp`	`Modifier.padding(16.sdpLh)`
`sdpLha`	`Dp`	`Modifier.padding(16.sdpLha)`
`sdpLhi`	`Dp`	`Modifier.padding(16.sdpLhi)`
`sdpLhia`	`Dp`	`Modifier.padding(16.sdpLhia)`
`sdpPxLh`	`Float`	`val px = 16.sdpPxLh`
`sdpPxaLh`	`Float`	`val px = 16.sdpPxaLh`
`sdpPxiLh`	`Float`	`val px = 16.sdpPxiLh`
`sdpPxiaLh`	`Float`	`val px = 16.sdpPxiaLh`
`sdpPw`	`Dp`	`Modifier.padding(16.sdpPw)`
`sdpPwa`	`Dp`	`Modifier.padding(16.sdpPwa)`
`sdpPwi`	`Dp`	`Modifier.padding(16.sdpPwi)`
`sdpPwia`	`Dp`	`Modifier.padding(16.sdpPwia)`
`sdpPxPw`	`Float`	`val px = 16.sdpPxPw`
`sdpPxaPw`	`Float`	`val px = 16.sdpPxaPw`
`sdpPxiPw`	`Float`	`val px = 16.sdpPxiPw`
`sdpPwiaPx`	`Float`	`val px = 16.sdpPwiaPx`
`sdpLw`	`Dp`	`Modifier.padding(16.sdpLw)`
`sdpLwa`	`Dp`	`Modifier.padding(16.sdpLwa)`
`sdpLwi`	`Dp`	`Modifier.padding(16.sdpLwi)`
`sdpLwia`	`Dp`	`Modifier.padding(16.sdpLwia)`
`sdpPxLw`	`Float`	`val px = 16.sdpPxLw`
`sdpPxaLw`	`Float`	`val px = 16.sdpPxaLw`
`sdpPxiLw`	`Float`	`val px = 16.sdpPxiLw`
`sdpPxiaLw`	`Float`	`val px = 16.sdpPxiaLw`
`hdp`	`Dp`	`Modifier.padding(16.hdp)`
`hdpa`	`Dp`	`Modifier.padding(16.hdpa)`
`hdpi`	`Dp`	`Modifier.padding(16.hdpi)`
`hdpia`	`Dp`	`Modifier.padding(16.hdpia)`
`hdpPx`	`Float`	`val px = 16.hdpPx`
`hdpaPx`	`Float`	`val px = 16.hdpaPx`
`hdpiPx`	`Float`	`val px = 16.hdpiPx`
`hdpiaPx`	`Float`	`val px = 16.hdpiaPx`
`hdpLw`	`Dp`	`Modifier.padding(16.hdpLw)`
`hdpLwa`	`Dp`	`Modifier.padding(16.hdpLwa)`
`hdpLwi`	`Dp`	`Modifier.padding(16.hdpLwi)`
`hdpLwia`	`Dp`	`Modifier.padding(16.hdpLwia)`
`hdpPxLw`	`Float`	`val px = 16.hdpPxLw`
`hdpPxaLw`	`Float`	`val px = 16.hdpPxaLw`
`hdpPxiLw`	`Float`	`val px = 16.hdpPxiLw`
`hdpPxiaLw`	`Float`	`val px = 16.hdpPxiaLw`
`hdpPw`	`Dp`	`Modifier.padding(16.hdpPw)`
`hdpPwa`	`Dp`	`Modifier.padding(16.hdpPwa)`
`hdpPwi`	`Dp`	`Modifier.padding(16.hdpPwi)`
`hdpPwia`	`Dp`	`Modifier.padding(16.hdpPwia)`
`hdpPxPw`	`Float`	`val px = 16.hdpPxPw`
`hdpPxaPw`	`Float`	`val px = 16.hdpPxaPw`
`hdpPxiPw`	`Float`	`val px = 16.hdpPxiPw`
`hdpPxiaPw`	`Float`	`val px = 16.hdpPxiaPw`
`wdp`	`Dp`	`Modifier.padding(16.wdp)`
`wdpa`	`Dp`	`Modifier.padding(16.wdpa)`
`wdpi`	`Dp`	`Modifier.padding(16.wdpi)`
`wdpia`	`Dp`	`Modifier.padding(16.wdpia)`
`wdpPx`	`Float`	`val px = 16.wdpPx`
`wdpaPx`	`Float`	`val px = 16.wdpaPx`
`wdpiPx`	`Float`	`val px = 16.wdpiPx`
`wdpiaPx`	`Float`	`val px = 16.wdpiaPx`
`wdpLh`	`Dp`	`Modifier.padding(16.wdpLh)`
`wdpLha`	`Dp`	`Modifier.padding(16.wdpLha)`
`wdpLhi`	`Dp`	`Modifier.padding(16.wdpLhi)`
`wdpLhia`	`Dp`	`Modifier.padding(16.wdpLhia)`
`wdpPxLh`	`Float`	`val px = 16.wdpPxLh`
`wdpPxaLh`	`Float`	`val px = 16.wdpPxaLh`
`wdpPxiLh`	`Float`	`val px = 16.wdpPxiLh`
`wdpPxiaLh`	`Float`	`val px = 16.wdpPxiaLh`
`wdpPh`	`Dp`	`Modifier.padding(16.wdpPh)`
`wdpPha`	`Dp`	`Modifier.padding(16.wdpPha)`
`wdpPhi`	`Dp`	`Modifier.padding(16.wdpPhi)`
`wdpPhia`	`Dp`	`Modifier.padding(16.wdpPhia)`
`wdpPxPh`	`Float`	`val px = 16.wdpPxPh`
`wdpPxaPh`	`Float`	`val px = 16.wdpPxaPh`
`wdpPxiPh`	`Float`	`val px = 16.wdpPxiPh`
`wdpPxiaPh`	`Float`	`val px = 16.wdpPxiaPh`

A.2 Scaled — `Number` Sp / px properties (`DimenSsp.kt`)

Property	Type	Example
`ssp`	`TextUnit`	`Text("Hi", fontSize = 16.ssp)`
`sspa`	`TextUnit`	`Text("Hi", fontSize = 16.sspa)`
`sspi`	`TextUnit`	`Text("Hi", fontSize = 16.sspi)`
`sspia`	`TextUnit`	`Text("Hi", fontSize = 16.sspia)`
`sspPx`	`Float`	`val px = 16.sspPx`
`sspPxa`	`Float`	`val px = 16.sspPxa`
`sspPxi`	`Float`	`val px = 16.sspPxi`
`sspPxia`	`Float`	`val px = 16.sspPxia`
`sem`	`TextUnit`	`Text("Hi", fontSize = 16.sem)`
`sema`	`TextUnit`	`Text("Hi", fontSize = 16.sema)`
`semi`	`TextUnit`	`Text("Hi", fontSize = 16.semi)`
`semia`	`TextUnit`	`Text("Hi", fontSize = 16.semia)`
`semPx`	`Float`	`val px = 16.semPx`
`semPxa`	`Float`	`val px = 16.semPxa`
`semPxi`	`Float`	`val px = 16.semPxi`
`semPxia`	`Float`	`val px = 16.semPxia`
`sspPh`	`TextUnit`	`Text("Hi", fontSize = 16.sspPh)`
`sspPha`	`TextUnit`	`Text("Hi", fontSize = 16.sspPha)`
`sspPhi`	`TextUnit`	`Text("Hi", fontSize = 16.sspPhi)`
`sspPhia`	`TextUnit`	`Text("Hi", fontSize = 16.sspPhia)`
`sspPxPh`	`Float`	`val px = 16.sspPxPh`
`sspPxaPh`	`Float`	`val px = 16.sspPxaPh`
`sspPxiPh`	`Float`	`val px = 16.sspPxiPh`
`sspPxiaPh`	`Float`	`val px = 16.sspPxiaPh`
`sspLh`	`TextUnit`	`Text("Hi", fontSize = 16.sspLh)`
`sspLha`	`TextUnit`	`Text("Hi", fontSize = 16.sspLha)`
`sspLhi`	`TextUnit`	`Text("Hi", fontSize = 16.sspLhi)`
`sspLhia`	`TextUnit`	`Text("Hi", fontSize = 16.sspLhia)`
`sspPxLh`	`Float`	`val px = 16.sspPxLh`
`sspPxaLh`	`Float`	`val px = 16.sspPxaLh`
`sspPxiLh`	`Float`	`val px = 16.sspPxiLh`
`sspPxiaLh`	`Float`	`val px = 16.sspPxiaLh`
`sspPw`	`TextUnit`	`Text("Hi", fontSize = 16.sspPw)`
`sspPwa`	`TextUnit`	`Text("Hi", fontSize = 16.sspPwa)`
`sspPwi`	`TextUnit`	`Text("Hi", fontSize = 16.sspPwi)`
`sspPwia`	`TextUnit`	`Text("Hi", fontSize = 16.sspPwia)`
`sspPxPw`	`Float`	`val px = 16.sspPxPw`
`sspPxaPw`	`Float`	`val px = 16.sspPxaPw`
`sspPxiPw`	`Float`	`val px = 16.sspPxiPw`
`sspPxiaPw`	`Float`	`val px = 16.sspPxiaPw`
`sspLw`	`TextUnit`	`Text("Hi", fontSize = 16.sspLw)`
`sspLwa`	`TextUnit`	`Text("Hi", fontSize = 16.sspLwa)`
`sspLwi`	`TextUnit`	`Text("Hi", fontSize = 16.sspLwi)`
`sspLwia`	`TextUnit`	`Text("Hi", fontSize = 16.sspLwia)`
`sspPxLw`	`Float`	`val px = 16.sspPxLw`
`sspPxaLw`	`Float`	`val px = 16.sspPxaLw`
`sspPxiLw`	`Float`	`val px = 16.sspPxiLw`
`sspPxiaLw`	`Float`	`val px = 16.sspPxiaLw`
`hsp`	`TextUnit`	`Text("Hi", fontSize = 16.hsp)`
`hspa`	`TextUnit`	`Text("Hi", fontSize = 16.hspa)`
`hspi`	`TextUnit`	`Text("Hi", fontSize = 16.hspi)`
`hspia`	`TextUnit`	`Text("Hi", fontSize = 16.hspia)`
`hspPx`	`Float`	`val px = 16.hspPx`
`hspPxa`	`Float`	`val px = 16.hspPxa`
`hspPxi`	`Float`	`val px = 16.hspPxi`
`hspPxia`	`Float`	`val px = 16.hspPxia`
`hem`	`TextUnit`	`Text("Hi", fontSize = 16.hem)`
`hema`	`TextUnit`	`Text("Hi", fontSize = 16.hema)`
`hemi`	`TextUnit`	`Text("Hi", fontSize = 16.hemi)`
`hemia`	`TextUnit`	`Text("Hi", fontSize = 16.hemia)`
`hemPx`	`Float`	`val px = 16.hemPx`
`hemPxa`	`Float`	`val px = 16.hemPxa`
`hemPxi`	`Float`	`val px = 16.hemPxi`
`hemPxia`	`Float`	`val px = 16.hemPxia`
`hspLw`	`TextUnit`	`Text("Hi", fontSize = 16.hspLw)`
`hspLwa`	`TextUnit`	`Text("Hi", fontSize = 16.hspLwa)`
`hspLwi`	`TextUnit`	`Text("Hi", fontSize = 16.hspLwi)`
`hspLwia`	`TextUnit`	`Text("Hi", fontSize = 16.hspLwia)`
`hspPxLw`	`Float`	`val px = 16.hspPxLw`
`hspPxaLw`	`Float`	`val px = 16.hspPxaLw`
`hspPxiLw`	`Float`	`val px = 16.hspPxiLw`
`hspPxiaLw`	`Float`	`val px = 16.hspPxiaLw`
`hspPw`	`TextUnit`	`Text("Hi", fontSize = 16.hspPw)`
`hspPwa`	`TextUnit`	`Text("Hi", fontSize = 16.hspPwa)`
`hspPwi`	`TextUnit`	`Text("Hi", fontSize = 16.hspPwi)`
`hspPwia`	`TextUnit`	`Text("Hi", fontSize = 16.hspPwia)`
`hspPxPw`	`Float`	`val px = 16.hspPxPw`
`hspPxaPw`	`Float`	`val px = 16.hspPxaPw`
`hspPxiPw`	`Float`	`val px = 16.hspPxiPw`
`hspPxiaPw`	`Float`	`val px = 16.hspPxiaPw`
`wsp`	`TextUnit`	`Text("Hi", fontSize = 16.wsp)`
`wspa`	`TextUnit`	`Text("Hi", fontSize = 16.wspa)`
`wspi`	`TextUnit`	`Text("Hi", fontSize = 16.wspi)`
`wspia`	`TextUnit`	`Text("Hi", fontSize = 16.wspia)`
`wspPx`	`Float`	`val px = 16.wspPx`
`wspPxa`	`Float`	`val px = 16.wspPxa`
`wspPxi`	`Float`	`val px = 16.wspPxi`
`wspPxia`	`Float`	`val px = 16.wspPxia`
`wem`	`TextUnit`	`Text("Hi", fontSize = 16.wem)`
`wema`	`TextUnit`	`Text("Hi", fontSize = 16.wema)`
`wemi`	`TextUnit`	`Text("Hi", fontSize = 16.wemi)`
`wemia`	`TextUnit`	`Text("Hi", fontSize = 16.wemia)`
`wemPx`	`Float`	`val px = 16.wemPx`
`wemPxa`	`Float`	`val px = 16.wemPxa`
`wemPxi`	`Float`	`val px = 16.wemPxi`
`wemPxia`	`Float`	`val px = 16.wemPxia`
`wspLh`	`TextUnit`	`Text("Hi", fontSize = 16.wspLh)`
`wspLha`	`TextUnit`	`Text("Hi", fontSize = 16.wspLha)`
`wspLhi`	`TextUnit`	`Text("Hi", fontSize = 16.wspLhi)`
`wspLhia`	`TextUnit`	`Text("Hi", fontSize = 16.wspLhia)`
`wspPxLh`	`Float`	`val px = 16.wspPxLh`
`wspPxaLh`	`Float`	`val px = 16.wspPxaLh`
`wspPxiLh`	`Float`	`val px = 16.wspPxiLh`
`wspPxiaLh`	`Float`	`val px = 16.wspPxiaLh`
`wspPh`	`TextUnit`	`Text("Hi", fontSize = 16.wspPh)`
`wspPha`	`TextUnit`	`Text("Hi", fontSize = 16.wspPha)`
`wspPhi`	`TextUnit`	`Text("Hi", fontSize = 16.wspPhi)`
`wspPhia`	`TextUnit`	`Text("Hi", fontSize = 16.wspPhia)`
`wspPxPh`	`Float`	`val px = 16.wspPxPh`
`wspPxaPh`	`Float`	`val px = 16.wspPxaPh`
`wspPxiPh`	`Float`	`val px = 16.wspPxiPh`
`wspPxiaPh`	`Float`	`val px = 16.wspPxiaPh`
`wemPh`	`TextUnit`	`Text("Hi", fontSize = 16.wemPh)`
`wemPha`	`TextUnit`	`Text("Hi", fontSize = 16.wemPha)`
`wemPhi`	`TextUnit`	`Text("Hi", fontSize = 16.wemPhi)`
`wemPhia`	`TextUnit`	`Text("Hi", fontSize = 16.wemPhia)`
`wemPxPh`	`Float`	`val px = 16.wemPxPh`
`wemPxaPh`	`Float`	`val px = 16.wemPxaPh`
`wemPxiPh`	`Float`	`val px = 16.wemPxiPh`
`wemPxiaPh`	`Float`	`val px = 16.wemPxiaPh`

Appendix B — Maintenance

When the library adds a new property or facilitator, update:

The Kotlin sources under library/src/main/java/com/appdimens/dynamic/compose/.
This file (or regenerate Appendix A with the project script).
The strategy overview in scaled.md and README.md.
Regenerate Dokka HTML (./gradlew :library:dokkaGenerateHtml → DOCUMENTATION2/), then run python3 scripts/sync_kdoc_from_dokka_html.py so DOCUMENTATION/KDOC/ matches renamed members (e.g. unitSizeInDp).
physical-units.md when DimenPhysicalUnits or code.units behavior changes.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Compose API reference — conventions and scaled module

1. Imports

2. Shared behavior (all strategies)

2.1 Flags on `Number` properties

2.2 `Px` variants

2.3 Orientation inverters (middle of the name)

2.4 Low-level composable functions (escape hatch)

3. Strategy prefix map (mirror of scaled)

4. Facilitators — Dp (`DimenSdpExtensions.kt`)

4.1 Rotation family

4.2 UI mode family (`UiModeType`)

4.3 Qualifier threshold family (`DpQualifier` + value)

4.4 Combined screen family (mode + qualifier)

4.5 Views / `code` — Plain (`Float` px + `Context`)

5. Facilitators — Sp (`DimenSsp.kt` + `DimenSspExtensions.kt`)

5.1 `Number` rotation (returns `TextUnit`)

5.2 `Number` px rotation

5.3 `TextUnit` rotation / mode / qualifier / screen

6. Builders — `DimenScaled` / `ScaledSp`

6.1 Entry points

6.2 Fluent configuration

6.3 `screen(...)` overloads (priority order)

6.4 Resolution properties (`DimenScaled`)

6.5 Resolution properties (`ScaledSp`)

Appendix A — Complete `Number` property catalog (scaled)

A.1 Scaled — `Number` Dp / px properties (`DimenSdp.kt`)

A.2 Scaled — `Number` Sp / px properties (`DimenSsp.kt`)

Appendix B — Maintenance

FilesExpand file tree

COMPOSE-API-CONVENTIONS.md

Latest commit

History

COMPOSE-API-CONVENTIONS.md

File metadata and controls

Compose API reference — conventions and scaled module

1. Imports

2. Shared behavior (all strategies)

2.1 Flags on Number properties

2.2 Px variants

2.3 Orientation inverters (middle of the name)

2.4 Low-level composable functions (escape hatch)

3. Strategy prefix map (mirror of scaled)

4. Facilitators — Dp (DimenSdpExtensions.kt)

4.1 Rotation family

4.2 UI mode family (UiModeType)

4.3 Qualifier threshold family (DpQualifier + value)

4.4 Combined screen family (mode + qualifier)

4.5 Views / code — Plain (Float px + Context)

5. Facilitators — Sp (DimenSsp.kt + DimenSspExtensions.kt)

5.1 Number rotation (returns TextUnit)

5.2 Number px rotation

5.3 TextUnit rotation / mode / qualifier / screen

6. Builders — DimenScaled / ScaledSp

6.1 Entry points

6.2 Fluent configuration

6.3 screen(...) overloads (priority order)

6.4 Resolution properties (DimenScaled)

6.5 Resolution properties (ScaledSp)

Appendix A — Complete Number property catalog (scaled)

A.1 Scaled — Number Dp / px properties (DimenSdp.kt)

A.2 Scaled — Number Sp / px properties (DimenSsp.kt)

Appendix B — Maintenance

2.1 Flags on `Number` properties

2.2 `Px` variants

4. Facilitators — Dp (`DimenSdpExtensions.kt`)

4.2 UI mode family (`UiModeType`)

4.3 Qualifier threshold family (`DpQualifier` + value)

4.5 Views / `code` — Plain (`Float` px + `Context`)

5. Facilitators — Sp (`DimenSsp.kt` + `DimenSspExtensions.kt`)

5.1 `Number` rotation (returns `TextUnit`)

5.2 `Number` px rotation

5.3 `TextUnit` rotation / mode / qualifier / screen

6. Builders — `DimenScaled` / `ScaledSp`

6.3 `screen(...)` overloads (priority order)

6.4 Resolution properties (`DimenScaled`)

6.5 Resolution properties (`ScaledSp`)

Appendix A — Complete `Number` property catalog (scaled)

A.1 Scaled — `Number` Dp / px properties (`DimenSdp.kt`)

A.2 Scaled — `Number` Sp / px properties (`DimenSsp.kt`)