diff --git a/.editorconfig b/.editorconfig index ac30459c21..2ab3cbeae7 100644 --- a/.editorconfig +++ b/.editorconfig @@ -913,3 +913,8 @@ ij_yaml_sequence_on_new_line = false ij_yaml_space_before_colon = false ij_yaml_spaces_within_braces = true ij_yaml_spaces_within_brackets = true + +[**/generated/**] +generated_code = true +ij_formatter_enabled = false +ktlint = disabled \ No newline at end of file diff --git a/.gitattributes b/.gitattributes index 5f13ff4efb..0a1fc8653d 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,4 +1,5 @@ screenshots/**/*.png filter=lfs diff=lfs merge=lfs -text +libraries/compound/screenshots/** filter=lfs diff=lfs merge=lfs -text **/snapshots/**/*.png filter=lfs diff=lfs merge=lfs -text **/docs/images-lfs/*.png filter=lfs diff=lfs merge=lfs -text libraries/mediaupload/impl/src/test/assets/* filter=lfs diff=lfs merge=lfs -text diff --git a/.github/workflows/scripts/recordScreenshots.sh b/.github/workflows/scripts/recordScreenshots.sh index a610c6cc69..19469e69e3 100755 --- a/.github/workflows/scripts/recordScreenshots.sh +++ b/.github/workflows/scripts/recordScreenshots.sh @@ -56,6 +56,12 @@ echo "Deleting previous screenshots" echo "Record screenshots" ./gradlew recordPaparazziDebug --stacktrace $GRADLE_ARGS +echo "Deleting previous screenshots" +./gradlew removeOldScreenshots --stacktrace --warn $GRADLE_ARGS + +echo "Record screenshots (Compound)" +./gradlew :libraries:compound:recordRoborazziDebug --stacktrace -PpreDexEnable=false --max-workers 4 --warn $GRADLE_ARGS + echo "Committing changes" git config http.sslVerify false diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index c0249642f4..22c302cbb3 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -78,6 +78,7 @@ jobs: name: tests-and-screenshot-tests-results path: | **/build/paparazzi/failures/ + **/build/roborazzi/failures/ **/build/reports/tests/*UnitTest/ # https://github.com/codecov/codecov-action diff --git a/build.gradle.kts b/build.gradle.kts index 7171d5b079..b7662aeb56 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -15,6 +15,7 @@ plugins { alias(libs.plugins.compose.compiler) apply false alias(libs.plugins.ksp) apply false alias(libs.plugins.dependencycheck) apply false + alias(libs.plugins.roborazzi) apply false alias(libs.plugins.dependencyanalysis) alias(libs.plugins.detekt) alias(libs.plugins.ktlint) @@ -192,6 +193,21 @@ subprojects { tasks.findByName("recordPaparazziRelease")?.dependsOn(removeOldScreenshotsTask) } +// Make sure to delete old snapshot before recording new ones +subprojects { + val screenshotsDir = File("${project.projectDir}/screenshots") + val removeOldScreenshotsTask = tasks.register("removeOldScreenshots") { + onlyIf { screenshotsDir.exists() } + doFirst { + println("Delete previous screenshots located at $screenshotsDir\n") + screenshotsDir.deleteRecursively() + } + } + tasks.findByName("recordRoborazzi")?.dependsOn(removeOldScreenshotsTask) + tasks.findByName("recordRoborazziDebug")?.dependsOn(removeOldScreenshotsTask) + tasks.findByName("recordRoborazziRelease")?.dependsOn(removeOldScreenshotsTask) +} + subprojects { tasks.withType().configureEach { compilerOptions { diff --git a/enterprise b/enterprise index 95789d4011..ffc02b8d0f 160000 --- a/enterprise +++ b/enterprise @@ -1 +1 @@ -Subproject commit 95789d40119499eba8a79284df9dd2306405b099 +Subproject commit ffc02b8d0f35188c3ef8a876dc1532bfe3e533da diff --git a/features/enterprise/api/build.gradle.kts b/features/enterprise/api/build.gradle.kts index 9f63ab2cf1..b32f42e31f 100644 --- a/features/enterprise/api/build.gradle.kts +++ b/features/enterprise/api/build.gradle.kts @@ -13,7 +13,7 @@ android { } dependencies { - implementation(libs.compound) + implementation(projects.libraries.compound) implementation(projects.libraries.architecture) implementation(projects.libraries.matrix.api) } diff --git a/features/enterprise/impl-foss/build.gradle.kts b/features/enterprise/impl-foss/build.gradle.kts index 956c0e1900..c5c194807f 100644 --- a/features/enterprise/impl-foss/build.gradle.kts +++ b/features/enterprise/impl-foss/build.gradle.kts @@ -18,7 +18,7 @@ android { setupDependencyInjection() dependencies { - implementation(libs.compound) + implementation(projects.libraries.compound) api(projects.features.enterprise.api) implementation(projects.libraries.architecture) implementation(projects.libraries.matrix.api) diff --git a/features/enterprise/test/build.gradle.kts b/features/enterprise/test/build.gradle.kts index 91b76f4fa7..38cc7aaaa9 100644 --- a/features/enterprise/test/build.gradle.kts +++ b/features/enterprise/test/build.gradle.kts @@ -14,7 +14,7 @@ android { dependencies { api(projects.features.enterprise.api) - implementation(libs.compound) + implementation(projects.libraries.compound) implementation(projects.libraries.matrix.api) implementation(projects.tests.testutils) } diff --git a/gradle.properties b/gradle.properties index 18399ccf06..a2c7228ed2 100644 --- a/gradle.properties +++ b/gradle.properties @@ -54,3 +54,7 @@ ksp.allow.all.target.configuration=false # Used to prevent detekt from reusing invalid cached rules detekt.use.worker.api=true + +# Let test include roborazzi verification +# https://github.com/takahirom/roborazzi?tab=readme-ov-file#roborazzitest +roborazzi.test.verify=true diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index d9990bbbf9..f837a1e55b 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -32,6 +32,7 @@ accompanist = "0.37.3" # Test test_core = "1.7.0" +roborazzi = "1.46.1" # Jetbrain datetime = "0.7.1" @@ -174,7 +175,6 @@ coil_network_okhttp = { module = "io.coil-kt.coil3:coil-network-okhttp", version coil_compose = { module = "io.coil-kt.coil3:coil-compose", version.ref = "coil" } coil_gif = { module = "io.coil-kt.coil3:coil-gif", version.ref = "coil" } coil_test = { module = "io.coil-kt.coil3:coil-test", version.ref = "coil" } -compound = { module = "io.element.android:compound-android", version = "25.7.4" } datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "datetime" } serialization_json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "serialization_json" } kotlinx_collections_immutable = "org.jetbrains.kotlinx:kotlinx-collections-immutable:0.4.0" @@ -227,6 +227,11 @@ google_autoservice_annotations = { module = "com.google.auto.service:auto-servic # Miscellaneous androidx-test-ext-junit = { group = "androidx.test.ext", name = "junit", version.ref = "androidx-test-ext-junit" } +# Test +test_roborazzi = { module = "io.github.takahirom.roborazzi:roborazzi", version.ref = "roborazzi" } +test_roborazzi_compose = { module = "io.github.takahirom.roborazzi:roborazzi-compose", version.ref = "roborazzi" } +test_roborazzi_junit = { module = "io.github.takahirom.roborazzi:roborazzi-junit-rule", version.ref = "roborazzi" } + [bundles] [plugins] @@ -244,6 +249,7 @@ dependencygraph = "com.savvasdalkitsis.module-dependency-graph:0.12" dependencycheck = "org.owasp.dependencycheck:12.1.6" dependencyanalysis = { id = "com.autonomousapps.dependency-analysis", version.ref = "dependencyAnalysis" } paparazzi = "app.cash.paparazzi:2.0.0-alpha02" +roborazzi = { id = "io.github.takahirom.roborazzi", version.ref = "roborazzi" } sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" } firebaseAppDistribution = { id = "com.google.firebase.appdistribution", version.ref = "firebaseAppDistribution" } knit = { id = "org.jetbrains.kotlinx.knit", version = "0.5.0" } diff --git a/libraries/compound/build.gradle.kts b/libraries/compound/build.gradle.kts new file mode 100644 index 0000000000..cbdb09d451 --- /dev/null +++ b/libraries/compound/build.gradle.kts @@ -0,0 +1,29 @@ +import extension.testCommonDependencies + +/* + * Copyright 2022, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +plugins { + id("io.element.android-compose-library") + alias(libs.plugins.roborazzi) +} + +android { + namespace = "io.element.android.compound" + + testOptions { + unitTests.isIncludeAndroidResources = true + } + + dependencies { + implementation(libs.showkase) + testCommonDependencies(libs) + testImplementation(libs.test.roborazzi) + testImplementation(libs.test.roborazzi.compose) + testImplementation(libs.test.roborazzi.junit) + } +} diff --git a/libraries/compound/screenshots/Avatar Colors - Dark.png b/libraries/compound/screenshots/Avatar Colors - Dark.png new file mode 100644 index 0000000000..5cf6cbda89 --- /dev/null +++ b/libraries/compound/screenshots/Avatar Colors - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:caf2de32caf0fa5368da899297e2eabd5a0c6891dd94f81295ef8a933d79ce16 +size 10751 diff --git a/libraries/compound/screenshots/Avatar Colors - Light.png b/libraries/compound/screenshots/Avatar Colors - Light.png new file mode 100644 index 0000000000..7069762082 --- /dev/null +++ b/libraries/compound/screenshots/Avatar Colors - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80e44e94d7b23af2ec4fd1c5a871851ae2567b40e478b30145de199076f20e95 +size 11296 diff --git a/libraries/compound/screenshots/Compound Icons - Dark.png b/libraries/compound/screenshots/Compound Icons - Dark.png new file mode 100644 index 0000000000..acac494f89 --- /dev/null +++ b/libraries/compound/screenshots/Compound Icons - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6bc48b9f792da838f9fc2c2a630cbbbb906de851a138cc1ac8b7bf67b801ad84 +size 211300 diff --git a/libraries/compound/screenshots/Compound Icons - Light.png b/libraries/compound/screenshots/Compound Icons - Light.png new file mode 100644 index 0000000000..c6b76c46bb --- /dev/null +++ b/libraries/compound/screenshots/Compound Icons - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e85fd2c67ff42829b8580ab5c0c2af1fee40973f5c0b34ef7de00e3663cee8e4 +size 223041 diff --git a/libraries/compound/screenshots/Compound Icons - Rtl.png b/libraries/compound/screenshots/Compound Icons - Rtl.png new file mode 100644 index 0000000000..ce2ffe2e88 --- /dev/null +++ b/libraries/compound/screenshots/Compound Icons - Rtl.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:406b62991171a146e891f95bcad0321ebc60cf1fe2cabc9caedbb17fb062af13 +size 224320 diff --git a/libraries/compound/screenshots/Compound Semantic Colors - Dark HC.png b/libraries/compound/screenshots/Compound Semantic Colors - Dark HC.png new file mode 100644 index 0000000000..4890b91886 --- /dev/null +++ b/libraries/compound/screenshots/Compound Semantic Colors - Dark HC.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:578e9b5a38791e2686a7b9ba5c461eb1d1fb29dfbe950bf46c113ad75ceac175 +size 327758 diff --git a/libraries/compound/screenshots/Compound Semantic Colors - Dark.png b/libraries/compound/screenshots/Compound Semantic Colors - Dark.png new file mode 100644 index 0000000000..4cc125b4c8 --- /dev/null +++ b/libraries/compound/screenshots/Compound Semantic Colors - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4cab40fc0506c8f2a2efafb1199e85f1da3ebacb49b176e9105e3f95175f85ee +size 325565 diff --git a/libraries/compound/screenshots/Compound Semantic Colors - Light HC.png b/libraries/compound/screenshots/Compound Semantic Colors - Light HC.png new file mode 100644 index 0000000000..5a8f5a6b32 --- /dev/null +++ b/libraries/compound/screenshots/Compound Semantic Colors - Light HC.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:174f9d4ee70a29c0c8c2a01a15daeb14281530678ff7d7fb19a208bfd789533a +size 309210 diff --git a/libraries/compound/screenshots/Compound Semantic Colors - Light.png b/libraries/compound/screenshots/Compound Semantic Colors - Light.png new file mode 100644 index 0000000000..f010626dda --- /dev/null +++ b/libraries/compound/screenshots/Compound Semantic Colors - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7598b98462c015f2bf74b3ea3ad95fc0220b2efb9bb81ac56025cf6a158e3f8a +size 308976 diff --git a/libraries/compound/screenshots/Compound Typography.png b/libraries/compound/screenshots/Compound Typography.png new file mode 100644 index 0000000000..095ad6c71d --- /dev/null +++ b/libraries/compound/screenshots/Compound Typography.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac84a7175c4a4897aa28eddcf722b7997c6576f612eb38fa09ffabcf7be11e00 +size 119496 diff --git a/libraries/compound/screenshots/Compound Vector Icons - Dark.png b/libraries/compound/screenshots/Compound Vector Icons - Dark.png new file mode 100644 index 0000000000..2b535c348b --- /dev/null +++ b/libraries/compound/screenshots/Compound Vector Icons - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6ff6dfdfab51332cad3bdfa351a4d0e305de5f899853575a8514858cc871e904 +size 83609 diff --git a/libraries/compound/screenshots/Compound Vector Icons - Light.png b/libraries/compound/screenshots/Compound Vector Icons - Light.png new file mode 100644 index 0000000000..bc29dcd24d --- /dev/null +++ b/libraries/compound/screenshots/Compound Vector Icons - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca38f5f23c282a6dc4c01a54705f71bf8c927aeac9c1df0a1f3abe50c10b1b85 +size 89336 diff --git a/libraries/compound/screenshots/ForcedDarkElementTheme.png b/libraries/compound/screenshots/ForcedDarkElementTheme.png new file mode 100644 index 0000000000..d7182aa47c --- /dev/null +++ b/libraries/compound/screenshots/ForcedDarkElementTheme.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03bdb2f3de01d40b8f85ba87b395cdab2e5225aded2f40a0892077798bca6066 +size 22328 diff --git a/libraries/compound/screenshots/Legacy Colors.png b/libraries/compound/screenshots/Legacy Colors.png new file mode 100644 index 0000000000..2ecdda2ed7 --- /dev/null +++ b/libraries/compound/screenshots/Legacy Colors.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e9d676a1ef20a7228e985f62d346265ff9c31d1860a219540f012c063c9345e +size 33652 diff --git a/libraries/compound/screenshots/Material Typography.png b/libraries/compound/screenshots/Material Typography.png new file mode 100644 index 0000000000..6c22c364b9 --- /dev/null +++ b/libraries/compound/screenshots/Material Typography.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d27f813acc9e8dc3960f5205809c8c0d2ba0fa51fd9e3ca07964b866b125e87d +size 110171 diff --git a/libraries/compound/screenshots/Material3 Colors - Dark HC.png b/libraries/compound/screenshots/Material3 Colors - Dark HC.png new file mode 100644 index 0000000000..4cc7609c89 --- /dev/null +++ b/libraries/compound/screenshots/Material3 Colors - Dark HC.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85969829577e158bdd1d0f21c8b3a2334dcde79cb50d5e2331d06d5423332be2 +size 160754 diff --git a/libraries/compound/screenshots/Material3 Colors - Dark.png b/libraries/compound/screenshots/Material3 Colors - Dark.png new file mode 100644 index 0000000000..3738cf6a79 --- /dev/null +++ b/libraries/compound/screenshots/Material3 Colors - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca64da1dc373dc49503ee525ae3331e73d0ab12053993a1ef19dcab1e67b08c4 +size 159123 diff --git a/libraries/compound/screenshots/Material3 Colors - Light HC.png b/libraries/compound/screenshots/Material3 Colors - Light HC.png new file mode 100644 index 0000000000..8d64857d13 --- /dev/null +++ b/libraries/compound/screenshots/Material3 Colors - Light HC.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01622bca20a132ec5a874fc1a2d0ffd45e7ce6d7849c4d607d79c7bc51d6c6a9 +size 163322 diff --git a/libraries/compound/screenshots/Material3 Colors - Light.png b/libraries/compound/screenshots/Material3 Colors - Light.png new file mode 100644 index 0000000000..a1d5d1f2ce --- /dev/null +++ b/libraries/compound/screenshots/Material3 Colors - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87c0c4ff42d17137d554708ce33f40f214ec608eca4ca87af0b2adab63de6bb7 +size 162891 diff --git a/libraries/compound/screenshots/MaterialText Colors.png b/libraries/compound/screenshots/MaterialText Colors.png new file mode 100644 index 0000000000..f8f77ccca2 --- /dev/null +++ b/libraries/compound/screenshots/MaterialText Colors.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4be10c3bb9900d27a3b406eca0cb902b0ff9cdf90e8e3cf1ae7760aa7c5d47d9 +size 377446 diff --git a/libraries/compound/screenshots/MaterialYou Theme - Dark.png b/libraries/compound/screenshots/MaterialYou Theme - Dark.png new file mode 100644 index 0000000000..8c5bc9d1ef --- /dev/null +++ b/libraries/compound/screenshots/MaterialYou Theme - Dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c166e5371bb1922a9c016438a3cdfd0d68197237969d53a04f92baf6d53c4ac0 +size 164925 diff --git a/libraries/compound/screenshots/MaterialYou Theme - Light.png b/libraries/compound/screenshots/MaterialYou Theme - Light.png new file mode 100644 index 0000000000..70cccac69b --- /dev/null +++ b/libraries/compound/screenshots/MaterialYou Theme - Light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d936948cbad69d6935f2d2738d33682a55f044dfb1af8b5c9b8323c5f4318971 +size 163558 diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/annotations/CoreColorToken.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/annotations/CoreColorToken.kt new file mode 100644 index 0000000000..a56ecb38a8 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/annotations/CoreColorToken.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.annotations + +@RequiresOptIn( + message = "This is a Core color token, which should only be used to declare semantic colors, otherwise it" + + " would look the same on both light and dark modes. Only use it as is if you know what you are doing." +) +@Retention(AnnotationRetention.BINARY) +@Target(AnnotationTarget.PROPERTY, AnnotationTarget.CLASS) +annotation class CoreColorToken diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorListPreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorListPreview.kt new file mode 100644 index 0000000000..715da1ebc3 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorListPreview.kt @@ -0,0 +1,57 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import kotlinx.collections.immutable.ImmutableMap +import kotlin.math.ceil + +@Composable +fun ColorListPreview( + backgroundColor: Color, + foregroundColor: Color, + colors: ImmutableMap, + modifier: Modifier = Modifier, + numColumns: Int = 1, +) { + Row( + modifier = modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + colors.keys + .chunked(ceil(colors.keys.size / numColumns.toDouble()).toInt()) + .forEach { subList -> + Column( + modifier = Modifier + .background(color = backgroundColor) + .weight(1f) + ) { + subList.forEach { name -> + val color = colors[name]!! + ColorPreview( + backgroundColor = backgroundColor, + foregroundColor = foregroundColor, + name = name, + color = color + ) + } + Spacer(modifier = Modifier.height(2.dp)) + } + } + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorPreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorPreview.kt new file mode 100644 index 0000000000..3248adeedf --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorPreview.kt @@ -0,0 +1,62 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import io.element.android.compound.utils.toHrf + +@Composable +fun ColorPreview( + backgroundColor: Color, + foregroundColor: Color, + name: String, + color: Color, + modifier: Modifier = Modifier, +) { + Column(modifier = modifier.fillMaxWidth()) { + Text( + modifier = Modifier.padding(horizontal = 10.dp), + text = name + " " + color.toHrf(), + fontSize = 6.sp, + color = foregroundColor, + ) + val backgroundBrush = Brush.linearGradient( + listOf( + backgroundColor, + foregroundColor, + ) + ) + Row( + modifier = Modifier.background(backgroundBrush) + ) { + repeat(2) { + Box( + modifier = Modifier + .padding(1.dp) + .background(Color.White) + .background(color = color) + .height(10.dp) + .weight(1f) + ) + } + } + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorsSchemePreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorsSchemePreview.kt new file mode 100644 index 0000000000..cf660ba236 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/ColorsSchemePreview.kt @@ -0,0 +1,60 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.material3.ColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import kotlinx.collections.immutable.persistentMapOf + +@Composable +internal fun ColorsSchemePreview( + backgroundColor: Color, + foregroundColor: Color, + colorScheme: ColorScheme, + modifier: Modifier = Modifier, +) { + val colors = persistentMapOf( + "primary" to colorScheme.primary, + "onPrimary" to colorScheme.onPrimary, + "primaryContainer" to colorScheme.primaryContainer, + "onPrimaryContainer" to colorScheme.onPrimaryContainer, + "inversePrimary" to colorScheme.inversePrimary, + "secondary" to colorScheme.secondary, + "onSecondary" to colorScheme.onSecondary, + "secondaryContainer" to colorScheme.secondaryContainer, + "onSecondaryContainer" to colorScheme.onSecondaryContainer, + "tertiary" to colorScheme.tertiary, + "onTertiary" to colorScheme.onTertiary, + "tertiaryContainer" to colorScheme.tertiaryContainer, + "onTertiaryContainer" to colorScheme.onTertiaryContainer, + "background" to colorScheme.background, + "onBackground" to colorScheme.onBackground, + "surface" to colorScheme.surface, + "onSurface" to colorScheme.onSurface, + "surfaceVariant" to colorScheme.surfaceVariant, + "onSurfaceVariant" to colorScheme.onSurfaceVariant, + "surfaceTint" to colorScheme.surfaceTint, + "inverseSurface" to colorScheme.inverseSurface, + "inverseOnSurface" to colorScheme.inverseOnSurface, + "error" to colorScheme.error, + "onError" to colorScheme.onError, + "errorContainer" to colorScheme.errorContainer, + "onErrorContainer" to colorScheme.onErrorContainer, + "outline" to colorScheme.outline, + "outlineVariant" to colorScheme.outlineVariant, + "scrim" to colorScheme.scrim, + ) + ColorListPreview( + backgroundColor = backgroundColor, + foregroundColor = foregroundColor, + colors = colors, + modifier = modifier, + ) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/CompoundIconsPreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/CompoundIconsPreview.kt new file mode 100644 index 0000000000..0ee0546ca4 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/CompoundIconsPreview.kt @@ -0,0 +1,143 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.IntrinsicSize +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalLayoutDirection +import androidx.compose.ui.res.vectorResource +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.LayoutDirection +import androidx.compose.ui.unit.dp +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.tokens.generated.CompoundIcons +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.toImmutableList + +@Preview(widthDp = 730, heightDp = 1800) +@Composable +internal fun IconsCompoundPreviewLight() = ElementTheme { + IconsCompoundPreview() +} + +@Preview(widthDp = 730, heightDp = 1800) +@Composable +internal fun IconsCompoundPreviewRtl() = ElementTheme { + CompositionLocalProvider( + LocalLayoutDirection provides LayoutDirection.Rtl, + ) { + IconsCompoundPreview( + title = "Compound Icons Rtl", + ) + } +} + +@Preview(widthDp = 730, heightDp = 1800) +@Composable +internal fun IconsCompoundPreviewDark() = ElementTheme(darkTheme = true) { + IconsCompoundPreview() +} + +@Composable +private fun IconsCompoundPreview( + title: String = "Compound Icons", +) { + val context = LocalContext.current + val content: Sequence<@Composable ColumnScope.() -> Unit> = sequence { + for (icon in CompoundIcons.allResIds) { + yield { + Icon( + modifier = Modifier.size(32.dp), + imageVector = ImageVector.vectorResource(icon), + contentDescription = null, + ) + Text( + modifier = Modifier.fillMaxWidth(), + text = context.resources.getResourceEntryName(icon) + .removePrefix("ic_compound_") + .replace("_", " "), + textAlign = TextAlign.Center, + style = ElementTheme.typography.fontBodyXsMedium, + color = ElementTheme.colors.textSecondary, + ) + } + } + } + IconsPreview( + title = title, + content = content.toImmutableList(), + ) +} + +@Composable +internal fun IconsPreview( + title: String, + content: ImmutableList<@Composable ColumnScope.() -> Unit>, +) = Surface { + Column( + modifier = Modifier + .background(MaterialTheme.colorScheme.surfaceVariant) + .padding(16.dp) + .width(IntrinsicSize.Max), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Text( + modifier = Modifier + .fillMaxWidth() + .padding(bottom = 16.dp), + style = ElementTheme.typography.fontHeadingSmMedium, + text = title, + textAlign = TextAlign.Center, + ) + content.chunked(10).forEach { chunk -> + Row( + modifier = Modifier.height(IntrinsicSize.Max), + // Keep same order of icons for an easier comparison of previews + horizontalArrangement = Arrangement.Absolute.Left, + ) { + chunk.forEachIndexed { index, icon -> + Column( + modifier = Modifier + .background(MaterialTheme.colorScheme.background) + .fillMaxHeight() + .width(64.dp) + .padding(4.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + icon() + } + if (index < chunk.size - 1) { + Spacer(modifier = Modifier.width(6.dp)) + } + } + } + } + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/SemanticColorsPreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/SemanticColorsPreview.kt new file mode 100644 index 0000000000..d641ff39c5 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/SemanticColorsPreview.kt @@ -0,0 +1,205 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.tokens.generated.compoundColorsHcDark +import kotlinx.collections.immutable.ImmutableMap +import kotlinx.collections.immutable.persistentMapOf + +@Preview(heightDp = 2000) +@Composable +internal fun CompoundSemanticColorsLight() = ElementTheme { + Surface { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text("Compound Semantic Colors - Light") + ColorListPreview( + backgroundColor = Color.White, + foregroundColor = Color.Black, + colors = getSemanticColors(), + numColumns = 2, + ) + } + } +} + +@Preview(heightDp = 2000) +@Composable +internal fun CompoundSemanticColorsLightHc() = ElementTheme( + compoundDark = compoundColorsHcDark, +) { + Surface { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text("Compound Semantic Colors - Light HC") + ColorListPreview( + backgroundColor = Color.White, + foregroundColor = Color.Black, + colors = getSemanticColors(), + numColumns = 2, + ) + } + } +} + +@Preview(heightDp = 2000) +@Composable +internal fun CompoundSemanticColorsDark() = ElementTheme(darkTheme = true) { + Surface { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text("Compound Semantic Colors - Dark") + ColorListPreview( + backgroundColor = Color.White, + foregroundColor = Color.Black, + colors = getSemanticColors(), + numColumns = 2, + ) + } + } +} + +@Preview(heightDp = 2000) +@Composable +internal fun CompoundSemanticColorsDarkHc() = ElementTheme( + darkTheme = true, + compoundDark = compoundColorsHcDark, +) { + Surface { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text("Compound Semantic Colors - Dark HC") + ColorListPreview( + backgroundColor = Color.White, + foregroundColor = Color.Black, + colors = getSemanticColors(), + numColumns = 2, + ) + } + } +} + +@Composable +private fun getSemanticColors(): ImmutableMap { + return with(ElementTheme.colors) { + persistentMapOf( + "bgAccentHovered" to bgAccentHovered, + "bgAccentPressed" to bgAccentPressed, + "bgAccentRest" to bgAccentRest, + "bgAccentSelected" to bgAccentSelected, + "bgActionPrimaryDisabled" to bgActionPrimaryDisabled, + "bgActionPrimaryHovered" to bgActionPrimaryHovered, + "bgActionPrimaryPressed" to bgActionPrimaryPressed, + "bgActionPrimaryRest" to bgActionPrimaryRest, + "bgActionSecondaryHovered" to bgActionSecondaryHovered, + "bgActionSecondaryPressed" to bgActionSecondaryPressed, + "bgActionSecondaryRest" to bgActionSecondaryRest, + "bgBadgeAccent" to bgBadgeAccent, + "bgBadgeDefault" to bgBadgeDefault, + "bgBadgeInfo" to bgBadgeInfo, + "bgCanvasDefault" to bgCanvasDefault, + "bgCanvasDefaultLevel1" to bgCanvasDefaultLevel1, + "bgCanvasDisabled" to bgCanvasDisabled, + "bgCriticalHovered" to bgCriticalHovered, + "bgCriticalPrimary" to bgCriticalPrimary, + "bgCriticalSubtle" to bgCriticalSubtle, + "bgCriticalSubtleHovered" to bgCriticalSubtleHovered, + "bgDecorative1" to bgDecorative1, + "bgDecorative2" to bgDecorative2, + "bgDecorative3" to bgDecorative3, + "bgDecorative4" to bgDecorative4, + "bgDecorative5" to bgDecorative5, + "bgDecorative6" to bgDecorative6, + "bgInfoSubtle" to bgInfoSubtle, + "bgSubtlePrimary" to bgSubtlePrimary, + "bgSubtleSecondary" to bgSubtleSecondary, + "bgSubtleSecondaryLevel0" to bgSubtleSecondaryLevel0, + "bgSuccessSubtle" to bgSuccessSubtle, + "borderAccentSubtle" to borderAccentSubtle, + "borderCriticalHovered" to borderCriticalHovered, + "borderCriticalPrimary" to borderCriticalPrimary, + "borderCriticalSubtle" to borderCriticalSubtle, + "borderDisabled" to borderDisabled, + "borderFocused" to borderFocused, + "borderInfoSubtle" to borderInfoSubtle, + "borderInteractiveHovered" to borderInteractiveHovered, + "borderInteractivePrimary" to borderInteractivePrimary, + "borderInteractiveSecondary" to borderInteractiveSecondary, + "borderSuccessSubtle" to borderSuccessSubtle, + "gradientActionStop1" to gradientActionStop1, + "gradientActionStop2" to gradientActionStop2, + "gradientActionStop3" to gradientActionStop3, + "gradientActionStop4" to gradientActionStop4, + "gradientInfoStop1" to gradientInfoStop1, + "gradientInfoStop2" to gradientInfoStop2, + "gradientInfoStop3" to gradientInfoStop3, + "gradientInfoStop4" to gradientInfoStop4, + "gradientInfoStop5" to gradientInfoStop5, + "gradientInfoStop6" to gradientInfoStop6, + "gradientSubtleStop1" to gradientSubtleStop1, + "gradientSubtleStop2" to gradientSubtleStop2, + "gradientSubtleStop3" to gradientSubtleStop3, + "gradientSubtleStop4" to gradientSubtleStop4, + "gradientSubtleStop5" to gradientSubtleStop5, + "gradientSubtleStop6" to gradientSubtleStop6, + "iconAccentPrimary" to iconAccentPrimary, + "iconAccentTertiary" to iconAccentTertiary, + "iconCriticalPrimary" to iconCriticalPrimary, + "iconDisabled" to iconDisabled, + "iconInfoPrimary" to iconInfoPrimary, + "iconOnSolidPrimary" to iconOnSolidPrimary, + "iconPrimary" to iconPrimary, + "iconPrimaryAlpha" to iconPrimaryAlpha, + "iconQuaternary" to iconQuaternary, + "iconQuaternaryAlpha" to iconQuaternaryAlpha, + "iconSecondary" to iconSecondary, + "iconSecondaryAlpha" to iconSecondaryAlpha, + "iconSuccessPrimary" to iconSuccessPrimary, + "iconTertiary" to iconTertiary, + "iconTertiaryAlpha" to iconTertiaryAlpha, + "textActionAccent" to textActionAccent, + "textActionPrimary" to textActionPrimary, + "textBadgeAccent" to textBadgeAccent, + "textBadgeInfo" to textBadgeInfo, + "textCriticalPrimary" to textCriticalPrimary, + "textDecorative1" to textDecorative1, + "textDecorative2" to textDecorative2, + "textDecorative3" to textDecorative3, + "textDecorative4" to textDecorative4, + "textDecorative5" to textDecorative5, + "textDecorative6" to textDecorative6, + "textDisabled" to textDisabled, + "textInfoPrimary" to textInfoPrimary, + "textLinkExternal" to textLinkExternal, + "textOnSolidPrimary" to textOnSolidPrimary, + "textPrimary" to textPrimary, + "textSecondary" to textSecondary, + "textSuccessPrimary" to textSuccessPrimary, + "isLight" to if (isLight) Color.White else Color.Black, + ) + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/previews/Typography.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/Typography.kt new file mode 100644 index 0000000000..5d5f31f203 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/previews/Typography.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.previews + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import io.element.android.compound.theme.ElementTheme + +@Preview +@Composable +internal fun TypographyPreview() = ElementTheme { + Surface { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + with(ElementTheme.materialTypography) { + TypographyTokenPreview(displayLarge, "Display large") + TypographyTokenPreview(displayMedium, "Display medium") + TypographyTokenPreview(displaySmall, "Display small") + TypographyTokenPreview(headlineLarge, "Headline large") + TypographyTokenPreview(headlineMedium, "Headline medium") + TypographyTokenPreview(headlineSmall, "Headline small") + TypographyTokenPreview(titleLarge, "Title large") + TypographyTokenPreview(titleMedium, "Title medium") + TypographyTokenPreview(titleSmall, "Title small") + TypographyTokenPreview(bodyLarge, "Body large") + TypographyTokenPreview(bodyMedium, "Body medium") + TypographyTokenPreview(bodySmall, "Body small") + TypographyTokenPreview(labelLarge, "Label large") + TypographyTokenPreview(labelMedium, "Label medium") + TypographyTokenPreview(labelSmall, "Label small") + } + } + } +} + +@Composable +private fun TypographyTokenPreview(style: TextStyle, text: String) { + Text(text = text, style = style) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/showkase/CompoundShowkaseRootModule.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/showkase/CompoundShowkaseRootModule.kt new file mode 100644 index 0000000000..f1c7b3f8d7 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/showkase/CompoundShowkaseRootModule.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.showkase + +import com.airbnb.android.showkase.annotation.ShowkaseRoot +import com.airbnb.android.showkase.annotation.ShowkaseRootModule + +@ShowkaseRoot +class CompoundShowkaseRootModule : ShowkaseRootModule diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/AvatarColors.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/AvatarColors.kt new file mode 100644 index 0000000000..506e1c8063 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/AvatarColors.kt @@ -0,0 +1,93 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.size +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import kotlinx.collections.immutable.ImmutableList +import kotlinx.collections.immutable.toImmutableList + +/** + * Data class to hold avatar colors. + */ +data class AvatarColors( + /** Background color for the avatar. */ + val background: Color, + /** Foreground color for the avatar. */ + val foreground: Color, +) + +/** + * Avatar colors using semantic tokens. + */ +@Composable +fun avatarColors(): List { + return listOf( + AvatarColors(background = ElementTheme.colors.bgDecorative1, foreground = ElementTheme.colors.textDecorative1), + AvatarColors(background = ElementTheme.colors.bgDecorative2, foreground = ElementTheme.colors.textDecorative2), + AvatarColors(background = ElementTheme.colors.bgDecorative3, foreground = ElementTheme.colors.textDecorative3), + AvatarColors(background = ElementTheme.colors.bgDecorative4, foreground = ElementTheme.colors.textDecorative4), + AvatarColors(background = ElementTheme.colors.bgDecorative5, foreground = ElementTheme.colors.textDecorative5), + AvatarColors(background = ElementTheme.colors.bgDecorative6, foreground = ElementTheme.colors.textDecorative6), + ) +} + +@Preview +@Composable +internal fun AvatarColorsPreviewLight() { + ElementTheme { + val chunks = avatarColors().chunked(4) + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + for (chunk in chunks) { + AvatarColorRow(chunk.toImmutableList()) + } + } + } +} + +@Preview +@Composable +internal fun AvatarColorsPreviewDark() { + ElementTheme(darkTheme = true) { + val chunks = avatarColors().chunked(4) + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + for (chunk in chunks) { + AvatarColorRow(chunk.toImmutableList()) + } + } + } +} + +@Composable +private fun AvatarColorRow(colors: ImmutableList) { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + colors.forEach { color -> + Box( + modifier = Modifier.size(48.dp) + .background(color.background), + ) { + Text( + modifier = Modifier.align(Alignment.Center), + text = "A", + color = color.foreground, + ) + } + } + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ElementTheme.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ElementTheme.kt new file mode 100644 index 0000000000..7535de0acd --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ElementTheme.kt @@ -0,0 +1,167 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import android.os.Build +import androidx.activity.ComponentActivity +import androidx.activity.SystemBarStyle +import androidx.activity.compose.LocalActivity +import androidx.activity.enableEdgeToEdge +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.ColorScheme +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Typography +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.ReadOnlyComposable +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.toArgb +import androidx.compose.ui.platform.LocalContext +import io.element.android.compound.tokens.compoundTypography +import io.element.android.compound.tokens.generated.SemanticColors +import io.element.android.compound.tokens.generated.TypographyTokens +import io.element.android.compound.tokens.generated.compoundColorsDark +import io.element.android.compound.tokens.generated.compoundColorsLight + +/** + * Inspired from https://medium.com/@lucasyujideveloper/54cbcbde1ace + */ +object ElementTheme { + /** + * The current [SemanticColors] provided by [ElementTheme]. + * These come from Compound and are the recommended colors to use for custom components. + * In Figma, these colors usually have the `Light/` or `Dark/` prefix. + */ + val colors: SemanticColors + @Composable + @ReadOnlyComposable + get() = LocalCompoundColors.current + + /** + * The current Material 3 [ColorScheme] provided by [ElementTheme], coming from [MaterialTheme]. + * In Figma, these colors usually have the `M3/` prefix. + */ + val materialColors: ColorScheme + @Composable + @ReadOnlyComposable + get() = MaterialTheme.colorScheme + + /** + * Compound [Typography] tokens. In Figma, these have the `Android/font/` prefix. + */ + val typography: TypographyTokens = TypographyTokens + + /** + * Material 3 [Typography] tokens. In Figma, these have the `M3 Typography/` prefix. + */ + val materialTypography: Typography + @Composable + @ReadOnlyComposable + get() = MaterialTheme.typography + + /** + * Returns whether the theme version used is the light or the dark one. + */ + val isLightTheme: Boolean + @Composable + @ReadOnlyComposable + get() = LocalCompoundColors.current.isLight +} + +// Global variables (application level) +internal val LocalCompoundColors = staticCompositionLocalOf { compoundColorsLight } + +/** + * Sets up the theme for the application, or a part of it. + * + * @param darkTheme whether to use the dark theme or not. If `true`, the dark theme will be used. + * @param applySystemBarsUpdate whether to update the system bars color scheme or not when the theme changes. It's `true` by default. + * This is specially useful when you want to apply an alternate theme to a part of the app but don't want it to affect the system bars. + * @param lightStatusBar whether to use a light status bar color scheme or not. By default, it's the opposite of [darkTheme]. + * @param dynamicColor whether to enable MaterialYou or not. It's `false` by default. + * @param compoundLight the [SemanticColors] to use in light theme. + * @param compoundDark the [SemanticColors] to use in dark theme. + * @param materialColorsLight the Material 3 [ColorScheme] to use in light theme. + * @param materialColorsDark the Material 3 [ColorScheme] to use in dark theme. + * @param typography the Material 3 [Typography] tokens to use. It'll use [compoundTypography] by default. + * @param content the content to apply the theme to. + */ +@Composable +fun ElementTheme( + darkTheme: Boolean = isSystemInDarkTheme(), + applySystemBarsUpdate: Boolean = true, + lightStatusBar: Boolean = !darkTheme, + // true to enable MaterialYou + dynamicColor: Boolean = false, + compoundLight: SemanticColors = compoundColorsLight, + compoundDark: SemanticColors = compoundColorsDark, + materialColorsLight: ColorScheme = compoundLight.toMaterialColorScheme(), + materialColorsDark: ColorScheme = compoundDark.toMaterialColorScheme(), + typography: Typography = compoundTypography, + content: @Composable () -> Unit, +) { + val currentCompoundColor = when { + darkTheme -> compoundDark + else -> compoundLight + } + + val colorScheme = when { + dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> { + val context = LocalContext.current + if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + } + darkTheme -> materialColorsDark + else -> materialColorsLight + } + + val statusBarColorScheme = if (dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + val context = LocalContext.current + if (lightStatusBar) { + dynamicDarkColorScheme(context) + } else { + dynamicLightColorScheme(context) + } + } else { + colorScheme + } + + if (applySystemBarsUpdate) { + val activity = LocalActivity.current as? ComponentActivity + LaunchedEffect(statusBarColorScheme, darkTheme, lightStatusBar) { + activity?.enableEdgeToEdge( + // For Status bar use the background color of the app + statusBarStyle = SystemBarStyle.auto( + lightScrim = statusBarColorScheme.background.toArgb(), + darkScrim = statusBarColorScheme.background.toArgb(), + detectDarkMode = { !lightStatusBar } + ), + // For Navigation bar use a transparent color so the content can be seen through it + navigationBarStyle = if (darkTheme) { + SystemBarStyle.dark(Color.Transparent.toArgb()) + } else { + SystemBarStyle.light(Color.Transparent.toArgb(), Color.Transparent.toArgb()) + } + ) + } + } + CompositionLocalProvider( + LocalCompoundColors provides currentCompoundColor, + LocalContentColor provides colorScheme.onSurface, + ) { + MaterialTheme( + colorScheme = colorScheme, + typography = typography, + content = content + ) + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ForcedDarkElementTheme.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ForcedDarkElementTheme.kt new file mode 100644 index 0000000000..cd168713ae --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/ForcedDarkElementTheme.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.activity.ComponentActivity +import androidx.activity.SystemBarStyle +import androidx.activity.compose.LocalActivity +import androidx.activity.enableEdgeToEdge +import androidx.compose.material3.MaterialTheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.toArgb + +/** + * Can be used to force a composable in dark theme. + * It will automatically change the system ui colors back to normal when leaving the composition. + */ +@Composable +fun ForcedDarkElementTheme( + lightStatusBar: Boolean = false, + content: @Composable () -> Unit, +) { + val colorScheme = MaterialTheme.colorScheme + val wasDarkTheme = !ElementTheme.colors.isLight + val activity = LocalActivity.current as? ComponentActivity + DisposableEffect(Unit) { + onDispose { + activity?.enableEdgeToEdge( + statusBarStyle = SystemBarStyle.auto( + lightScrim = colorScheme.background.toArgb(), + darkScrim = colorScheme.background.toArgb(), + ), + navigationBarStyle = if (wasDarkTheme) { + SystemBarStyle.dark(Color.Transparent.toArgb()) + } else { + SystemBarStyle.light( + scrim = Color.Transparent.toArgb(), + darkScrim = Color.Transparent.toArgb() + ) + } + ) + } + } + ElementTheme(darkTheme = true, lightStatusBar = lightStatusBar, content = content) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/LegacyColors.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/LegacyColors.kt new file mode 100644 index 0000000000..6b7814d1e3 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/LegacyColors.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.ui.graphics.Color +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.internal.DarkColorTokens +import io.element.android.compound.tokens.generated.internal.LightColorTokens + +// ================================================================================================= +// IMPORTANT! +// We should not be adding any new colors here. This file is only for legacy colors. +// In fact, we should try to remove any references to these colors as we +// iterate through the designs. All new colors should come from Compound's Design Tokens. +// ================================================================================================= + +val LinkColor = Color(0xFF0086E6) + +@OptIn(CoreColorToken::class) +val SnackBarLabelColorLight = LightColorTokens.colorGray700 +@OptIn(CoreColorToken::class) +val SnackBarLabelColorDark = DarkColorTokens.colorGray700 diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeDark.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeDark.kt new file mode 100644 index 0000000000..7ee6b631b5 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeDark.kt @@ -0,0 +1,52 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.material3.ColorScheme +import androidx.compose.material3.darkColorScheme +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.SemanticColors +import io.element.android.compound.tokens.generated.internal.DarkColorTokens + +/** + * See the mapping in + * https://www.figma.com/design/G1xy0HDZKJf5TCRFmKb5d5/Compound-Android-Components?node-id=311-14&p=f&t=QcVyNaPEZMDA6RFK-0 + */ +@OptIn(CoreColorToken::class) +fun SemanticColors.toMaterialColorSchemeDark(): ColorScheme = darkColorScheme( + primary = bgActionPrimaryRest, + onPrimary = textOnSolidPrimary, + primaryContainer = bgCanvasDefault, + onPrimaryContainer = textPrimary, + inversePrimary = textOnSolidPrimary, + secondary = textSecondary, + onSecondary = textOnSolidPrimary, + secondaryContainer = bgSubtlePrimary, + onSecondaryContainer = textPrimary, + tertiary = textSecondary, + onTertiary = textOnSolidPrimary, + tertiaryContainer = bgActionPrimaryRest, + onTertiaryContainer = textOnSolidPrimary, + background = bgCanvasDefault, + onBackground = textPrimary, + surface = bgCanvasDefault, + onSurface = textPrimary, + surfaceVariant = bgSubtleSecondary, + onSurfaceVariant = textSecondary, + surfaceTint = DarkColorTokens.colorGray1000, + inverseSurface = DarkColorTokens.colorGray1300, + inverseOnSurface = textOnSolidPrimary, + error = textCriticalPrimary, + onError = textOnSolidPrimary, + errorContainer = DarkColorTokens.colorRed400, + onErrorContainer = textCriticalPrimary, + outline = borderInteractivePrimary, + outlineVariant = DarkColorTokens.colorAlphaGray400, + // Note: for light it will be colorGray1400 + scrim = DarkColorTokens.colorGray300, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeLight.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeLight.kt new file mode 100644 index 0000000000..b179234429 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialColorSchemeLight.kt @@ -0,0 +1,52 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.material3.ColorScheme +import androidx.compose.material3.lightColorScheme +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.SemanticColors +import io.element.android.compound.tokens.generated.internal.LightColorTokens + +/** + * See the mapping in + * https://www.figma.com/design/G1xy0HDZKJf5TCRFmKb5d5/Compound-Android-Components?node-id=311-14&p=f&t=QcVyNaPEZMDA6RFK-0 + */ +@OptIn(CoreColorToken::class) +fun SemanticColors.toMaterialColorSchemeLight(): ColorScheme = lightColorScheme( + primary = bgActionPrimaryRest, + onPrimary = textOnSolidPrimary, + primaryContainer = bgCanvasDefault, + onPrimaryContainer = textPrimary, + inversePrimary = textOnSolidPrimary, + secondary = textSecondary, + onSecondary = textOnSolidPrimary, + secondaryContainer = bgSubtlePrimary, + onSecondaryContainer = textPrimary, + tertiary = textSecondary, + onTertiary = textOnSolidPrimary, + tertiaryContainer = bgActionPrimaryRest, + onTertiaryContainer = textOnSolidPrimary, + background = bgCanvasDefault, + onBackground = textPrimary, + surface = bgCanvasDefault, + onSurface = textPrimary, + surfaceVariant = bgSubtleSecondary, + onSurfaceVariant = textSecondary, + surfaceTint = LightColorTokens.colorGray1000, + inverseSurface = LightColorTokens.colorGray1300, + inverseOnSurface = textOnSolidPrimary, + error = textCriticalPrimary, + onError = textOnSolidPrimary, + errorContainer = LightColorTokens.colorRed400, + onErrorContainer = textCriticalPrimary, + outline = borderInteractivePrimary, + outlineVariant = LightColorTokens.colorAlphaGray400, + // Note: for dark it will be colorGray300 + scrim = LightColorTokens.colorGray1400, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialTextPreview.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialTextPreview.kt new file mode 100644 index 0000000000..724d440161 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialTextPreview.kt @@ -0,0 +1,138 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.LocalTextStyle +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import io.element.android.compound.utils.toHrf + +@Preview(heightDp = 1200, widthDp = 420) +@Composable +internal fun MaterialTextPreview() = Row( + modifier = Modifier.background(Color.Yellow) +) { + MaterialPreview( + modifier = Modifier.weight(1f), + darkTheme = false, + ) + MaterialPreview( + modifier = Modifier.weight(1f), + darkTheme = true, + ) +} + +private data class Model( + val name: String, + val bgColor: Color, + val textColor: Color, +) + +@Composable +private fun MaterialPreview( + darkTheme: Boolean, + modifier: Modifier = Modifier, +) = Column(modifier = modifier) { + Text( + modifier = Modifier + .fillMaxWidth() + .padding(8.dp), + textAlign = TextAlign.Center, + text = if (darkTheme) "Dark" else "Light", + color = Color.Black, + fontSize = 18.sp, + fontWeight = FontWeight.Bold, + ) + ElementTheme( + darkTheme = darkTheme, + ) { + Column( + modifier = Modifier.fillMaxSize() + ) { + listOf( + Model("Background", MaterialTheme.colorScheme.background, MaterialTheme.colorScheme.onBackground), + Model("Primary", MaterialTheme.colorScheme.primary, MaterialTheme.colorScheme.onPrimary), + Model("PrimaryContainer", MaterialTheme.colorScheme.primaryContainer, MaterialTheme.colorScheme.onPrimaryContainer), + Model("Secondary", MaterialTheme.colorScheme.secondary, MaterialTheme.colorScheme.onSecondary), + Model("SecondaryContainer", MaterialTheme.colorScheme.secondaryContainer, MaterialTheme.colorScheme.onSecondaryContainer), + Model("Tertiary", MaterialTheme.colorScheme.tertiary, MaterialTheme.colorScheme.onTertiary), + Model("TertiaryContainer", MaterialTheme.colorScheme.tertiaryContainer, MaterialTheme.colorScheme.onTertiaryContainer), + Model("Surface", MaterialTheme.colorScheme.surface, MaterialTheme.colorScheme.onSurface), + Model("SurfaceVariant", MaterialTheme.colorScheme.surfaceVariant, MaterialTheme.colorScheme.onSurfaceVariant), + Model("InverseSurface", MaterialTheme.colorScheme.inverseSurface, MaterialTheme.colorScheme.inverseOnSurface), + Model("Error", MaterialTheme.colorScheme.error, MaterialTheme.colorScheme.onError), + Model("ErrorContainer", MaterialTheme.colorScheme.errorContainer, MaterialTheme.colorScheme.onErrorContainer), + ).forEach { + TextPreview( + name = it.name, + bgColor = it.bgColor, + textColor = it.textColor, + ) + } + Box( + modifier = Modifier + .padding(1.dp) + .fillMaxWidth() + .background(MaterialTheme.colorScheme.background) + ) { + Text( + text = "Below\n".repeat(3), + color = MaterialTheme.colorScheme.onBackground, + ) + Text( + modifier = Modifier + .padding(12.dp) + .fillMaxWidth() + // the alpha applied to the scrim color does not seem to be mandatory. + // The library ignores the alpha level provided and apply it's own. + // For testing the color, manually set an alpha. + .background(color = MaterialTheme.colorScheme.scrim.copy(alpha = 0.32f)) + .padding(16.dp), + text = "${"Scrim"}\n${MaterialTheme.colorScheme.scrim.toHrf()}", + style = LocalTextStyle.current.copy(fontFamily = FontFamily.Monospace), + textAlign = TextAlign.Center, + color = MaterialTheme.colorScheme.onBackground, + ) + } + } + } +} + +@Composable +private fun TextPreview( + name: String, + bgColor: Color, + textColor: Color, + modifier: Modifier = Modifier, +) = Text( + modifier = modifier + .padding(1.dp) + .fillMaxWidth() + .background(bgColor) + .padding(horizontal = 16.dp, vertical = 8.dp), + text = "$name\n${textColor.toHrf()}\n${bgColor.toHrf()}", + style = LocalTextStyle.current.copy(fontFamily = FontFamily.Monospace), + textAlign = TextAlign.Center, + color = textColor, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialThemeColors.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialThemeColors.kt new file mode 100644 index 0000000000..f81b0a94f6 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/MaterialThemeColors.kt @@ -0,0 +1,72 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.material3.ColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.tooling.preview.Preview +import io.element.android.compound.previews.ColorsSchemePreview +import io.element.android.compound.tokens.generated.SemanticColors +import io.element.android.compound.tokens.generated.compoundColorsHcDark +import io.element.android.compound.tokens.generated.compoundColorsHcLight + +fun SemanticColors.toMaterialColorScheme(): ColorScheme { + return if (isLight) { + toMaterialColorSchemeLight() + } else { + toMaterialColorSchemeDark() + } +} + +@Preview(heightDp = 1200) +@Composable +internal fun ColorsSchemeLightPreview() = ElementTheme { + ColorsSchemePreview( + Color.Black, + Color.White, + ElementTheme.materialColors, + ) +} + +@Preview(heightDp = 1200) +@Composable +internal fun ColorsSchemeLightHcPreview() = ElementTheme( + compoundLight = compoundColorsHcLight, +) { + ColorsSchemePreview( + Color.Black, + Color.White, + ElementTheme.materialColors, + ) +} + +@Preview(heightDp = 1200) +@Composable +internal fun ColorsSchemeDarkPreview() = ElementTheme( + darkTheme = true, +) { + ColorsSchemePreview( + Color.White, + Color.Black, + ElementTheme.materialColors, + ) +} + +@Preview(heightDp = 1200) +@Composable +internal fun ColorsSchemeDarkHcPreview() = ElementTheme( + darkTheme = true, + compoundDark = compoundColorsHcDark, +) { + ColorsSchemePreview( + Color.White, + Color.Black, + ElementTheme.materialColors, + ) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/theme/Theme.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/Theme.kt new file mode 100644 index 0000000000..c6e9b47eb7 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/theme/Theme.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.theme + +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.runtime.Composable +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.map + +enum class Theme { + System, + Dark, + Light, +} + +val themes = listOf(Theme.System, Theme.Dark, Theme.Light) + +@Composable +fun Theme.isDark(): Boolean { + return when (this) { + Theme.System -> isSystemInDarkTheme() + Theme.Dark -> true + Theme.Light -> false + } +} + +fun Flow.mapToTheme(): Flow = map { + when (it) { + null -> Theme.System + else -> Theme.valueOf(it) + } +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/CompoundTypography.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/CompoundTypography.kt new file mode 100644 index 0000000000..ab4d898ba4 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/CompoundTypography.kt @@ -0,0 +1,93 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.tokens + +import androidx.compose.material3.Typography +import androidx.compose.ui.text.PlatformTextStyle +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.LineHeightStyle +import androidx.compose.ui.unit.em +import androidx.compose.ui.unit.sp +import com.airbnb.android.showkase.annotation.ShowkaseTypography +import io.element.android.compound.tokens.generated.TypographyTokens + +// 32px (Material) vs 34px, it's the closest one +@ShowkaseTypography(name = "M3 Headline Large", group = "Compound") +internal val compoundHeadingXlRegular = TypographyTokens.fontHeadingXlRegular + +// both are 28px +@ShowkaseTypography(name = "M3 Headline Medium", group = "Compound") +internal val compoundHeadingLgRegular = TypographyTokens.fontHeadingLgRegular + +// These are the default M3 values, but we're setting them manually so an update in M3 doesn't break our designs +@ShowkaseTypography(name = "M3 Headline Small", group = "Compound") +internal val defaultHeadlineSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + lineHeight = 32.sp, + fontSize = 24.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) +) + +// 22px (Material) vs 20px, it's the closest one +@ShowkaseTypography(name = "M3 Title Large", group = "Compound") +internal val compoundHeadingMdRegular = TypographyTokens.fontHeadingMdRegular + +// 16px both +@ShowkaseTypography(name = "M3 Title Medium", group = "Compound") +internal val compoundBodyLgMedium = TypographyTokens.fontBodyLgMedium + +// 14px both +@ShowkaseTypography(name = "M3 Title Small", group = "Compound") +internal val compoundBodyMdMedium = TypographyTokens.fontBodyMdMedium + +// 16px both +@ShowkaseTypography(name = "M3 Body Large", group = "Compound") +internal val compoundBodyLgRegular = TypographyTokens.fontBodyLgRegular + +// 14px both +@ShowkaseTypography(name = "M3 Body Medium", group = "Compound") +internal val compoundBodyMdRegular = TypographyTokens.fontBodyMdRegular + +// 12px both +@ShowkaseTypography(name = "M3 Body Small", group = "Compound") +internal val compoundBodySmRegular = TypographyTokens.fontBodySmRegular + +// 14px both, Title Small uses the same token so we have to declare it twice +@ShowkaseTypography(name = "M3 Label Large", group = "Compound") +internal val compoundBodyMdMedium_LabelLarge = TypographyTokens.fontBodyMdMedium + +// 12px both +@ShowkaseTypography(name = "M3 Label Medium", group = "Compound") +internal val compoundBodySmMedium = TypographyTokens.fontBodySmMedium + +// 11px both +@ShowkaseTypography(name = "M3 Label Small", group = "Compound") +internal val compoundBodyXsMedium = TypographyTokens.fontBodyXsMedium + +internal val compoundTypography = Typography( + // displayLarge = , 57px (Material) size. We have no equivalent + // displayMedium = , 45px (Material) size. We have no equivalent + // displaySmall = , 36px (Material) size. We have no equivalent + headlineLarge = compoundHeadingXlRegular, + headlineMedium = compoundHeadingLgRegular, + headlineSmall = defaultHeadlineSmall, + titleLarge = compoundHeadingMdRegular, + titleMedium = compoundBodyLgMedium, + titleSmall = compoundBodyMdMedium, + bodyLarge = compoundBodyLgRegular, + bodyMedium = compoundBodyMdRegular, + bodySmall = compoundBodySmRegular, + labelLarge = compoundBodyMdMedium_LabelLarge, + labelMedium = compoundBodySmMedium, + labelSmall = compoundBodyXsMedium, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/CompoundIcons.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/CompoundIcons.kt new file mode 100644 index 0000000000..76b3275651 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/CompoundIcons.kt @@ -0,0 +1,1034 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import io.element.android.compound.R +import androidx.compose.runtime.Composable +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.res.vectorResource +import kotlinx.collections.immutable.persistentListOf + +object CompoundIcons { + @Composable fun Admin(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_admin) + } + @Composable fun ArrowDown(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_arrow_down) + } + @Composable fun ArrowLeft(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_arrow_left) + } + @Composable fun ArrowRight(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_arrow_right) + } + @Composable fun ArrowUp(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_arrow_up) + } + @Composable fun ArrowUpRight(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_arrow_up_right) + } + @Composable fun AskToJoin(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_ask_to_join) + } + @Composable fun AskToJoinSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_ask_to_join_solid) + } + @Composable fun Attachment(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_attachment) + } + @Composable fun Audio(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_audio) + } + @Composable fun Block(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_block) + } + @Composable fun Bold(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_bold) + } + @Composable fun Calendar(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_calendar) + } + @Composable fun Chart(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chart) + } + @Composable fun Chat(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chat) + } + @Composable fun ChatNew(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chat_new) + } + @Composable fun ChatProblem(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chat_problem) + } + @Composable fun ChatSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chat_solid) + } + @Composable fun Check(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_check) + } + @Composable fun CheckCircle(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_check_circle) + } + @Composable fun CheckCircleSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_check_circle_solid) + } + @Composable fun ChevronDown(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chevron_down) + } + @Composable fun ChevronLeft(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chevron_left) + } + @Composable fun ChevronRight(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chevron_right) + } + @Composable fun ChevronUp(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chevron_up) + } + @Composable fun ChevronUpDown(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_chevron_up_down) + } + @Composable fun Circle(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_circle) + } + @Composable fun Close(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_close) + } + @Composable fun Cloud(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_cloud) + } + @Composable fun CloudSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_cloud_solid) + } + @Composable fun Code(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_code) + } + @Composable fun Collapse(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_collapse) + } + @Composable fun Company(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_company) + } + @Composable fun Compose(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_compose) + } + @Composable fun Computer(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_computer) + } + @Composable fun Copy(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_copy) + } + @Composable fun DarkMode(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_dark_mode) + } + @Composable fun Delete(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_delete) + } + @Composable fun Devices(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_devices) + } + @Composable fun DialPad(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_dial_pad) + } + @Composable fun Document(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_document) + } + @Composable fun Download(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_download) + } + @Composable fun DownloadIos(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_download_ios) + } + @Composable fun DragGrid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_drag_grid) + } + @Composable fun DragList(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_drag_list) + } + @Composable fun Earpiece(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_earpiece) + } + @Composable fun Edit(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_edit) + } + @Composable fun EditSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_edit_solid) + } + @Composable fun Email(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_email) + } + @Composable fun EmailSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_email_solid) + } + @Composable fun EndCall(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_end_call) + } + @Composable fun Error(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_error) + } + @Composable fun ErrorSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_error_solid) + } + @Composable fun Expand(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_expand) + } + @Composable fun Explore(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_explore) + } + @Composable fun ExportArchive(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_export_archive) + } + @Composable fun Extensions(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_extensions) + } + @Composable fun ExtensionsSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_extensions_solid) + } + @Composable fun Favourite(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_favourite) + } + @Composable fun FavouriteSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_favourite_solid) + } + @Composable fun FileError(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_file_error) + } + @Composable fun Files(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_files) + } + @Composable fun Filter(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_filter) + } + @Composable fun Forward(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_forward) + } + @Composable fun Grid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_grid) + } + @Composable fun Group(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_group) + } + @Composable fun Guest(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_guest) + } + @Composable fun HeadphonesOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_headphones_off_solid) + } + @Composable fun HeadphonesSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_headphones_solid) + } + @Composable fun Help(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_help) + } + @Composable fun HelpSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_help_solid) + } + @Composable fun History(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_history) + } + @Composable fun Home(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_home) + } + @Composable fun HomeSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_home_solid) + } + @Composable fun Host(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_host) + } + @Composable fun Image(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_image) + } + @Composable fun ImageError(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_image_error) + } + @Composable fun IndentDecrease(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_indent_decrease) + } + @Composable fun IndentIncrease(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_indent_increase) + } + @Composable fun Info(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_info) + } + @Composable fun InfoSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_info_solid) + } + @Composable fun InlineCode(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_inline_code) + } + @Composable fun Italic(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_italic) + } + @Composable fun Key(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_key) + } + @Composable fun KeyOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_key_off) + } + @Composable fun KeyOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_key_off_solid) + } + @Composable fun KeySolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_key_solid) + } + @Composable fun Keyboard(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_keyboard) + } + @Composable fun Labs(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_labs) + } + @Composable fun Leave(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_leave) + } + @Composable fun Link(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_link) + } + @Composable fun Linux(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_linux) + } + @Composable fun ListBulleted(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_list_bulleted) + } + @Composable fun ListNumbered(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_list_numbered) + } + @Composable fun ListView(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_list_view) + } + @Composable fun LocationNavigator(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_location_navigator) + } + @Composable fun LocationNavigatorCentred(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_location_navigator_centred) + } + @Composable fun LocationPin(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_location_pin) + } + @Composable fun LocationPinSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_location_pin_solid) + } + @Composable fun Lock(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_lock) + } + @Composable fun LockOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_lock_off) + } + @Composable fun LockSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_lock_solid) + } + @Composable fun Mac(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mac) + } + @Composable fun MarkAsRead(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mark_as_read) + } + @Composable fun MarkAsUnread(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mark_as_unread) + } + @Composable fun MarkThreadsAsRead(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mark_threads_as_read) + } + @Composable fun MarkerReadReceipts(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_marker_read_receipts) + } + @Composable fun Mention(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mention) + } + @Composable fun Menu(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_menu) + } + @Composable fun MicOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mic_off) + } + @Composable fun MicOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mic_off_solid) + } + @Composable fun MicOn(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mic_on) + } + @Composable fun MicOnSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mic_on_solid) + } + @Composable fun Minus(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_minus) + } + @Composable fun Mobile(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_mobile) + } + @Composable fun Notifications(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_notifications) + } + @Composable fun NotificationsOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_notifications_off) + } + @Composable fun NotificationsOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_notifications_off_solid) + } + @Composable fun NotificationsSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_notifications_solid) + } + @Composable fun Offline(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_offline) + } + @Composable fun OverflowHorizontal(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_overflow_horizontal) + } + @Composable fun OverflowVertical(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_overflow_vertical) + } + @Composable fun Pause(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_pause) + } + @Composable fun PauseSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_pause_solid) + } + @Composable fun Pin(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_pin) + } + @Composable fun PinSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_pin_solid) + } + @Composable fun Play(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_play) + } + @Composable fun PlaySolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_play_solid) + } + @Composable fun Plus(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_plus) + } + @Composable fun Polls(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_polls) + } + @Composable fun PollsEnd(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_polls_end) + } + @Composable fun PopOut(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_pop_out) + } + @Composable fun Preferences(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_preferences) + } + @Composable fun PresenceOutline8X8(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_presence_outline_8_x_8) + } + @Composable fun PresenceSolid8X8(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_presence_solid_8_x_8) + } + @Composable fun PresenceStrikethrough8X8(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_presence_strikethrough_8_x_8) + } + @Composable fun Public(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_public) + } + @Composable fun QrCode(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_qr_code) + } + @Composable fun Quote(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_quote) + } + @Composable fun RaisedHandSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_raised_hand_solid) + } + @Composable fun Reaction(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_reaction) + } + @Composable fun ReactionAdd(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_reaction_add) + } + @Composable fun ReactionSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_reaction_solid) + } + @Composable fun Reply(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_reply) + } + @Composable fun Restart(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_restart) + } + @Composable fun Room(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_room) + } + @Composable fun Search(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_search) + } + @Composable fun Send(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_send) + } + @Composable fun SendSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_send_solid) + } + @Composable fun Settings(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_settings) + } + @Composable fun SettingsSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_settings_solid) + } + @Composable fun Share(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_share) + } + @Composable fun ShareAndroid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_share_android) + } + @Composable fun ShareIos(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_share_ios) + } + @Composable fun ShareScreen(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_share_screen) + } + @Composable fun ShareScreenSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_share_screen_solid) + } + @Composable fun Shield(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_shield) + } + @Composable fun Sidebar(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_sidebar) + } + @Composable fun SignOut(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_sign_out) + } + @Composable fun Spinner(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_spinner) + } + @Composable fun Spotlight(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_spotlight) + } + @Composable fun SpotlightView(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_spotlight_view) + } + @Composable fun Strikethrough(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_strikethrough) + } + @Composable fun SwitchCameraSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_switch_camera_solid) + } + @Composable fun TakePhoto(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_take_photo) + } + @Composable fun TakePhotoSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_take_photo_solid) + } + @Composable fun TextFormatting(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_text_formatting) + } + @Composable fun Threads(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_threads) + } + @Composable fun ThreadsSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_threads_solid) + } + @Composable fun Time(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_time) + } + @Composable fun Underline(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_underline) + } + @Composable fun Unknown(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_unknown) + } + @Composable fun UnknownSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_unknown_solid) + } + @Composable fun Unpin(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_unpin) + } + @Composable fun User(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user) + } + @Composable fun UserAdd(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user_add) + } + @Composable fun UserAddSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user_add_solid) + } + @Composable fun UserProfile(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user_profile) + } + @Composable fun UserProfileSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user_profile_solid) + } + @Composable fun UserSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_user_solid) + } + @Composable fun Verified(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_verified) + } + @Composable fun VideoCall(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call) + } + @Composable fun VideoCallDeclinedSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call_declined_solid) + } + @Composable fun VideoCallMissedSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call_missed_solid) + } + @Composable fun VideoCallOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call_off) + } + @Composable fun VideoCallOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call_off_solid) + } + @Composable fun VideoCallSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_video_call_solid) + } + @Composable fun VisibilityOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_visibility_off) + } + @Composable fun VisibilityOn(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_visibility_on) + } + @Composable fun VoiceCall(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_voice_call) + } + @Composable fun VoiceCallSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_voice_call_solid) + } + @Composable fun VolumeOff(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_volume_off) + } + @Composable fun VolumeOffSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_volume_off_solid) + } + @Composable fun VolumeOn(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_volume_on) + } + @Composable fun VolumeOnSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_volume_on_solid) + } + @Composable fun Warning(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_warning) + } + @Composable fun WebBrowser(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_web_browser) + } + @Composable fun Windows(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_windows) + } + @Composable fun Workspace(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_workspace) + } + @Composable fun WorkspaceSolid(): ImageVector { + return ImageVector.vectorResource(R.drawable.ic_compound_workspace_solid) + } + + val all @Composable get() = persistentListOf( + Admin(), + ArrowDown(), + ArrowLeft(), + ArrowRight(), + ArrowUp(), + ArrowUpRight(), + AskToJoin(), + AskToJoinSolid(), + Attachment(), + Audio(), + Block(), + Bold(), + Calendar(), + Chart(), + Chat(), + ChatNew(), + ChatProblem(), + ChatSolid(), + Check(), + CheckCircle(), + CheckCircleSolid(), + ChevronDown(), + ChevronLeft(), + ChevronRight(), + ChevronUp(), + ChevronUpDown(), + Circle(), + Close(), + Cloud(), + CloudSolid(), + Code(), + Collapse(), + Company(), + Compose(), + Computer(), + Copy(), + DarkMode(), + Delete(), + Devices(), + DialPad(), + Document(), + Download(), + DownloadIos(), + DragGrid(), + DragList(), + Earpiece(), + Edit(), + EditSolid(), + Email(), + EmailSolid(), + EndCall(), + Error(), + ErrorSolid(), + Expand(), + Explore(), + ExportArchive(), + Extensions(), + ExtensionsSolid(), + Favourite(), + FavouriteSolid(), + FileError(), + Files(), + Filter(), + Forward(), + Grid(), + Group(), + Guest(), + HeadphonesOffSolid(), + HeadphonesSolid(), + Help(), + HelpSolid(), + History(), + Home(), + HomeSolid(), + Host(), + Image(), + ImageError(), + IndentDecrease(), + IndentIncrease(), + Info(), + InfoSolid(), + InlineCode(), + Italic(), + Key(), + KeyOff(), + KeyOffSolid(), + KeySolid(), + Keyboard(), + Labs(), + Leave(), + Link(), + Linux(), + ListBulleted(), + ListNumbered(), + ListView(), + LocationNavigator(), + LocationNavigatorCentred(), + LocationPin(), + LocationPinSolid(), + Lock(), + LockOff(), + LockSolid(), + Mac(), + MarkAsRead(), + MarkAsUnread(), + MarkThreadsAsRead(), + MarkerReadReceipts(), + Mention(), + Menu(), + MicOff(), + MicOffSolid(), + MicOn(), + MicOnSolid(), + Minus(), + Mobile(), + Notifications(), + NotificationsOff(), + NotificationsOffSolid(), + NotificationsSolid(), + Offline(), + OverflowHorizontal(), + OverflowVertical(), + Pause(), + PauseSolid(), + Pin(), + PinSolid(), + Play(), + PlaySolid(), + Plus(), + Polls(), + PollsEnd(), + PopOut(), + Preferences(), + PresenceOutline8X8(), + PresenceSolid8X8(), + PresenceStrikethrough8X8(), + Public(), + QrCode(), + Quote(), + RaisedHandSolid(), + Reaction(), + ReactionAdd(), + ReactionSolid(), + Reply(), + Restart(), + Room(), + Search(), + Send(), + SendSolid(), + Settings(), + SettingsSolid(), + Share(), + ShareAndroid(), + ShareIos(), + ShareScreen(), + ShareScreenSolid(), + Shield(), + Sidebar(), + SignOut(), + Spinner(), + Spotlight(), + SpotlightView(), + Strikethrough(), + SwitchCameraSolid(), + TakePhoto(), + TakePhotoSolid(), + TextFormatting(), + Threads(), + ThreadsSolid(), + Time(), + Underline(), + Unknown(), + UnknownSolid(), + Unpin(), + User(), + UserAdd(), + UserAddSolid(), + UserProfile(), + UserProfileSolid(), + UserSolid(), + Verified(), + VideoCall(), + VideoCallDeclinedSolid(), + VideoCallMissedSolid(), + VideoCallOff(), + VideoCallOffSolid(), + VideoCallSolid(), + VisibilityOff(), + VisibilityOn(), + VoiceCall(), + VoiceCallSolid(), + VolumeOff(), + VolumeOffSolid(), + VolumeOn(), + VolumeOnSolid(), + Warning(), + WebBrowser(), + Windows(), + Workspace(), + WorkspaceSolid(), + ) + + val allResIds get() = persistentListOf( + R.drawable.ic_compound_admin, + R.drawable.ic_compound_arrow_down, + R.drawable.ic_compound_arrow_left, + R.drawable.ic_compound_arrow_right, + R.drawable.ic_compound_arrow_up, + R.drawable.ic_compound_arrow_up_right, + R.drawable.ic_compound_ask_to_join, + R.drawable.ic_compound_ask_to_join_solid, + R.drawable.ic_compound_attachment, + R.drawable.ic_compound_audio, + R.drawable.ic_compound_block, + R.drawable.ic_compound_bold, + R.drawable.ic_compound_calendar, + R.drawable.ic_compound_chart, + R.drawable.ic_compound_chat, + R.drawable.ic_compound_chat_new, + R.drawable.ic_compound_chat_problem, + R.drawable.ic_compound_chat_solid, + R.drawable.ic_compound_check, + R.drawable.ic_compound_check_circle, + R.drawable.ic_compound_check_circle_solid, + R.drawable.ic_compound_chevron_down, + R.drawable.ic_compound_chevron_left, + R.drawable.ic_compound_chevron_right, + R.drawable.ic_compound_chevron_up, + R.drawable.ic_compound_chevron_up_down, + R.drawable.ic_compound_circle, + R.drawable.ic_compound_close, + R.drawable.ic_compound_cloud, + R.drawable.ic_compound_cloud_solid, + R.drawable.ic_compound_code, + R.drawable.ic_compound_collapse, + R.drawable.ic_compound_company, + R.drawable.ic_compound_compose, + R.drawable.ic_compound_computer, + R.drawable.ic_compound_copy, + R.drawable.ic_compound_dark_mode, + R.drawable.ic_compound_delete, + R.drawable.ic_compound_devices, + R.drawable.ic_compound_dial_pad, + R.drawable.ic_compound_document, + R.drawable.ic_compound_download, + R.drawable.ic_compound_download_ios, + R.drawable.ic_compound_drag_grid, + R.drawable.ic_compound_drag_list, + R.drawable.ic_compound_earpiece, + R.drawable.ic_compound_edit, + R.drawable.ic_compound_edit_solid, + R.drawable.ic_compound_email, + R.drawable.ic_compound_email_solid, + R.drawable.ic_compound_end_call, + R.drawable.ic_compound_error, + R.drawable.ic_compound_error_solid, + R.drawable.ic_compound_expand, + R.drawable.ic_compound_explore, + R.drawable.ic_compound_export_archive, + R.drawable.ic_compound_extensions, + R.drawable.ic_compound_extensions_solid, + R.drawable.ic_compound_favourite, + R.drawable.ic_compound_favourite_solid, + R.drawable.ic_compound_file_error, + R.drawable.ic_compound_files, + R.drawable.ic_compound_filter, + R.drawable.ic_compound_forward, + R.drawable.ic_compound_grid, + R.drawable.ic_compound_group, + R.drawable.ic_compound_guest, + R.drawable.ic_compound_headphones_off_solid, + R.drawable.ic_compound_headphones_solid, + R.drawable.ic_compound_help, + R.drawable.ic_compound_help_solid, + R.drawable.ic_compound_history, + R.drawable.ic_compound_home, + R.drawable.ic_compound_home_solid, + R.drawable.ic_compound_host, + R.drawable.ic_compound_image, + R.drawable.ic_compound_image_error, + R.drawable.ic_compound_indent_decrease, + R.drawable.ic_compound_indent_increase, + R.drawable.ic_compound_info, + R.drawable.ic_compound_info_solid, + R.drawable.ic_compound_inline_code, + R.drawable.ic_compound_italic, + R.drawable.ic_compound_key, + R.drawable.ic_compound_key_off, + R.drawable.ic_compound_key_off_solid, + R.drawable.ic_compound_key_solid, + R.drawable.ic_compound_keyboard, + R.drawable.ic_compound_labs, + R.drawable.ic_compound_leave, + R.drawable.ic_compound_link, + R.drawable.ic_compound_linux, + R.drawable.ic_compound_list_bulleted, + R.drawable.ic_compound_list_numbered, + R.drawable.ic_compound_list_view, + R.drawable.ic_compound_location_navigator, + R.drawable.ic_compound_location_navigator_centred, + R.drawable.ic_compound_location_pin, + R.drawable.ic_compound_location_pin_solid, + R.drawable.ic_compound_lock, + R.drawable.ic_compound_lock_off, + R.drawable.ic_compound_lock_solid, + R.drawable.ic_compound_mac, + R.drawable.ic_compound_mark_as_read, + R.drawable.ic_compound_mark_as_unread, + R.drawable.ic_compound_mark_threads_as_read, + R.drawable.ic_compound_marker_read_receipts, + R.drawable.ic_compound_mention, + R.drawable.ic_compound_menu, + R.drawable.ic_compound_mic_off, + R.drawable.ic_compound_mic_off_solid, + R.drawable.ic_compound_mic_on, + R.drawable.ic_compound_mic_on_solid, + R.drawable.ic_compound_minus, + R.drawable.ic_compound_mobile, + R.drawable.ic_compound_notifications, + R.drawable.ic_compound_notifications_off, + R.drawable.ic_compound_notifications_off_solid, + R.drawable.ic_compound_notifications_solid, + R.drawable.ic_compound_offline, + R.drawable.ic_compound_overflow_horizontal, + R.drawable.ic_compound_overflow_vertical, + R.drawable.ic_compound_pause, + R.drawable.ic_compound_pause_solid, + R.drawable.ic_compound_pin, + R.drawable.ic_compound_pin_solid, + R.drawable.ic_compound_play, + R.drawable.ic_compound_play_solid, + R.drawable.ic_compound_plus, + R.drawable.ic_compound_polls, + R.drawable.ic_compound_polls_end, + R.drawable.ic_compound_pop_out, + R.drawable.ic_compound_preferences, + R.drawable.ic_compound_presence_outline_8_x_8, + R.drawable.ic_compound_presence_solid_8_x_8, + R.drawable.ic_compound_presence_strikethrough_8_x_8, + R.drawable.ic_compound_public, + R.drawable.ic_compound_qr_code, + R.drawable.ic_compound_quote, + R.drawable.ic_compound_raised_hand_solid, + R.drawable.ic_compound_reaction, + R.drawable.ic_compound_reaction_add, + R.drawable.ic_compound_reaction_solid, + R.drawable.ic_compound_reply, + R.drawable.ic_compound_restart, + R.drawable.ic_compound_room, + R.drawable.ic_compound_search, + R.drawable.ic_compound_send, + R.drawable.ic_compound_send_solid, + R.drawable.ic_compound_settings, + R.drawable.ic_compound_settings_solid, + R.drawable.ic_compound_share, + R.drawable.ic_compound_share_android, + R.drawable.ic_compound_share_ios, + R.drawable.ic_compound_share_screen, + R.drawable.ic_compound_share_screen_solid, + R.drawable.ic_compound_shield, + R.drawable.ic_compound_sidebar, + R.drawable.ic_compound_sign_out, + R.drawable.ic_compound_spinner, + R.drawable.ic_compound_spotlight, + R.drawable.ic_compound_spotlight_view, + R.drawable.ic_compound_strikethrough, + R.drawable.ic_compound_switch_camera_solid, + R.drawable.ic_compound_take_photo, + R.drawable.ic_compound_take_photo_solid, + R.drawable.ic_compound_text_formatting, + R.drawable.ic_compound_threads, + R.drawable.ic_compound_threads_solid, + R.drawable.ic_compound_time, + R.drawable.ic_compound_underline, + R.drawable.ic_compound_unknown, + R.drawable.ic_compound_unknown_solid, + R.drawable.ic_compound_unpin, + R.drawable.ic_compound_user, + R.drawable.ic_compound_user_add, + R.drawable.ic_compound_user_add_solid, + R.drawable.ic_compound_user_profile, + R.drawable.ic_compound_user_profile_solid, + R.drawable.ic_compound_user_solid, + R.drawable.ic_compound_verified, + R.drawable.ic_compound_video_call, + R.drawable.ic_compound_video_call_declined_solid, + R.drawable.ic_compound_video_call_missed_solid, + R.drawable.ic_compound_video_call_off, + R.drawable.ic_compound_video_call_off_solid, + R.drawable.ic_compound_video_call_solid, + R.drawable.ic_compound_visibility_off, + R.drawable.ic_compound_visibility_on, + R.drawable.ic_compound_voice_call, + R.drawable.ic_compound_voice_call_solid, + R.drawable.ic_compound_volume_off, + R.drawable.ic_compound_volume_off_solid, + R.drawable.ic_compound_volume_on, + R.drawable.ic_compound_volume_on_solid, + R.drawable.ic_compound_warning, + R.drawable.ic_compound_web_browser, + R.drawable.ic_compound_windows, + R.drawable.ic_compound_workspace, + R.drawable.ic_compound_workspace_solid, + ) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/DO_NOT_MODIFY.txt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/DO_NOT_MODIFY.txt new file mode 100644 index 0000000000..a6f7dd3f6a --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/DO_NOT_MODIFY.txt @@ -0,0 +1 @@ +Files inside this package are generated automatically from the Compound project (https://github.com/vector-im/compound-design-tokens) and will be batch-replaced when new tokens are generated. diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColors.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColors.kt new file mode 100644 index 0000000000..8da51213f8 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColors.kt @@ -0,0 +1,222 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import androidx.compose.runtime.Immutable +import androidx.compose.ui.graphics.Color + + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + + +/** + * This class holds all the semantic tokens of the Compound theme. + */ +@Immutable +data class SemanticColors( + /** Background colour for accent or brand actions. State: Hover */ + val bgAccentHovered: Color, + /** Background colour for accent or brand actions. State: Pressed */ + val bgAccentPressed: Color, + /** Background colour for accent or brand actions. State: Rest. */ + val bgAccentRest: Color, + /** Background colour for accent or brand actions. State: Selected */ + val bgAccentSelected: Color, + /** Background colour for primary actions. State: Disabled. */ + val bgActionPrimaryDisabled: Color, + /** Background colour for primary actions. State: Hover. */ + val bgActionPrimaryHovered: Color, + /** Background colour for primary actions. State: Pressed. */ + val bgActionPrimaryPressed: Color, + /** Background colour for primary actions. State: Rest. */ + val bgActionPrimaryRest: Color, + /** Background colour for secondary actions. State: Hover. */ + val bgActionSecondaryHovered: Color, + /** Background colour for secondary actions. State: Pressed. */ + val bgActionSecondaryPressed: Color, + /** Background colour for secondary actions. State: Rest. */ + val bgActionSecondaryRest: Color, + /** Badge accent background colour */ + val bgBadgeAccent: Color, + /** Badge default background colour */ + val bgBadgeDefault: Color, + /** Badge info background colour */ + val bgBadgeInfo: Color, + /** Default global background for the user interface. +Elevation: Default (Level 0) */ + val bgCanvasDefault: Color, + /** Default global background for the user interface. +Elevation: Level 1. */ + val bgCanvasDefaultLevel1: Color, + /** Default background for disabled elements. There's no minimum contrast requirement. */ + val bgCanvasDisabled: Color, + /** High-contrast background color for critical state. State: Hover. */ + val bgCriticalHovered: Color, + /** High-contrast background color for critical state. State: Rest. */ + val bgCriticalPrimary: Color, + /** Default subtle critical surfaces. State: Rest. */ + val bgCriticalSubtle: Color, + /** Default subtle critical surfaces. State: Hover. */ + val bgCriticalSubtleHovered: Color, + /** Decorative background (1, Lime) for avatars and usernames. */ + val bgDecorative1: Color, + /** Decorative background (2, Cyan) for avatars and usernames. */ + val bgDecorative2: Color, + /** Decorative background (3, Fuchsia) for avatars and usernames. */ + val bgDecorative3: Color, + /** Decorative background (4, Purple) for avatars and usernames. */ + val bgDecorative4: Color, + /** Decorative background (5, Pink) for avatars and usernames. */ + val bgDecorative5: Color, + /** Decorative background (6, Orange) for avatars and usernames. */ + val bgDecorative6: Color, + /** Subtle background colour for informational elements. State: Rest. */ + val bgInfoSubtle: Color, + /** Medium contrast surfaces. +Elevation: Default (Level 2). */ + val bgSubtlePrimary: Color, + /** Low contrast surfaces. +Elevation: Default (Level 1). */ + val bgSubtleSecondary: Color, + /** Lower contrast surfaces. +Elevation: Level 0. */ + val bgSubtleSecondaryLevel0: Color, + /** Subtle background colour for success state elements. State: Rest. */ + val bgSuccessSubtle: Color, + /** accent border intended for keylines on message highlights */ + val borderAccentSubtle: Color, + /** High-contrast border for critical state. State: Hover. */ + val borderCriticalHovered: Color, + /** High-contrast border for critical state. State: Rest. */ + val borderCriticalPrimary: Color, + /** Subtle border colour for critical state elements. */ + val borderCriticalSubtle: Color, + /** Used for borders of disabled elements. There's no minimum contrast requirement. */ + val borderDisabled: Color, + /** Used for the focus state outline. */ + val borderFocused: Color, + /** Subtle border colour for informational elements. */ + val borderInfoSubtle: Color, + /** Default contrast for accessible interactive element borders. State: Hover. */ + val borderInteractiveHovered: Color, + /** Default contrast for accessible interactive element borders. State: Rest. */ + val borderInteractivePrimary: Color, + /** ⚠️ Lowest contrast for non-accessible interactive element borders, <3:1. Only use for non-essential borders. Do not rely exclusively on them. State: Rest. */ + val borderInteractiveSecondary: Color, + /** Subtle border colour for success state elements. */ + val borderSuccessSubtle: Color, + /** Background gradient stop for super and send buttons */ + val gradientActionStop1: Color, + /** Background gradient stop for super and send buttons */ + val gradientActionStop2: Color, + /** Background gradient stop for super and send buttons */ + val gradientActionStop3: Color, + /** Background gradient stop for super and send buttons */ + val gradientActionStop4: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop1: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop2: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop3: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop4: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop5: Color, + /** Subtle background gradient stop for info */ + val gradientInfoStop6: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop1: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop2: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop3: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop4: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop5: Color, + /** Subtle background gradient stop for message highlight and bloom */ + val gradientSubtleStop6: Color, + /** Highest contrast accessible accent icons. */ + val iconAccentPrimary: Color, + /** Lowest contrast accessible accent icons. */ + val iconAccentTertiary: Color, + /** High-contrast icon for critical state. State: Rest. */ + val iconCriticalPrimary: Color, + /** Use for icons in disabled elements. There's no minimum contrast requirement. */ + val iconDisabled: Color, + /** High-contrast icon for informational elements. */ + val iconInfoPrimary: Color, + /** Highest contrast icon color on top of high-contrast solid backgrounds like primary, accent, or destructive actions. */ + val iconOnSolidPrimary: Color, + /** Highest contrast icons. */ + val iconPrimary: Color, + /** Translucent version of primary icon. Refer to it for intended use. */ + val iconPrimaryAlpha: Color, + /** ⚠️ Lowest contrast non-accessible icons, <3:1. Only use for non-essential icons. Do not rely exclusively on them. */ + val iconQuaternary: Color, + /** Translucent version of quaternary icon. Refer to it for intended use. */ + val iconQuaternaryAlpha: Color, + /** Lower contrast icons. */ + val iconSecondary: Color, + /** Translucent version of secondary icon. Refer to it for intended use. */ + val iconSecondaryAlpha: Color, + /** High-contrast icon for success state elements. */ + val iconSuccessPrimary: Color, + /** Lowest contrast accessible icons. */ + val iconTertiary: Color, + /** Translucent version of tertiary icon. Refer to it for intended use. */ + val iconTertiaryAlpha: Color, + /** Accent text colour for plain actions. */ + val textActionAccent: Color, + /** Default text colour for plain actions. */ + val textActionPrimary: Color, + /** Badge accent text colour */ + val textBadgeAccent: Color, + /** Badge info text colour */ + val textBadgeInfo: Color, + /** Text colour for destructive plain actions. */ + val textCriticalPrimary: Color, + /** Decorative text colour (1, Lime) for avatars and usernames. */ + val textDecorative1: Color, + /** Decorative text colour (2, Cyan) for avatars and usernames. */ + val textDecorative2: Color, + /** Decorative text colour (3, Fuchsia) for avatars and usernames. */ + val textDecorative3: Color, + /** Decorative text colour (4, Purple) for avatars and usernames. */ + val textDecorative4: Color, + /** Decorative text colour (5, Pink) for avatars and usernames. */ + val textDecorative5: Color, + /** Decorative text colour (6, Orange) for avatars and usernames. */ + val textDecorative6: Color, + /** Use for regular text in disabled elements. There's no minimum contrast requirement. */ + val textDisabled: Color, + /** Accent text colour for informational elements. */ + val textInfoPrimary: Color, + /** Text colour for external links. */ + val textLinkExternal: Color, + /** For use as text color on top of high-contrast solid backgrounds like primary, accent, or destructive actions. */ + val textOnSolidPrimary: Color, + /** Highest contrast text. */ + val textPrimary: Color, + /** Lowest contrast text. */ + val textSecondary: Color, + /** Accent text colour for success state elements. */ + val textSuccessPrimary: Color, + /** True for light theme, false for dark theme. */ + val isLight: Boolean, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDark.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDark.kt new file mode 100644 index 0000000000..5ccdfaa308 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDark.kt @@ -0,0 +1,121 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.internal.DarkColorTokens + +/** + * Semantic colors for the dark Compound theme. + */ +@OptIn(CoreColorToken::class) +val compoundColorsDark = SemanticColors( + bgAccentHovered = DarkColorTokens.colorGreen1000, + bgAccentPressed = DarkColorTokens.colorGreen1100, + bgAccentRest = DarkColorTokens.colorGreen900, + bgAccentSelected = DarkColorTokens.colorAlphaGreen300, + bgActionPrimaryDisabled = DarkColorTokens.colorGray700, + bgActionPrimaryHovered = DarkColorTokens.colorGray1200, + bgActionPrimaryPressed = DarkColorTokens.colorGray1100, + bgActionPrimaryRest = DarkColorTokens.colorGray1400, + bgActionSecondaryHovered = DarkColorTokens.colorAlphaGray200, + bgActionSecondaryPressed = DarkColorTokens.colorAlphaGray300, + bgActionSecondaryRest = DarkColorTokens.colorThemeBg, + bgBadgeAccent = DarkColorTokens.colorAlphaGreen300, + bgBadgeDefault = DarkColorTokens.colorAlphaGray300, + bgBadgeInfo = DarkColorTokens.colorAlphaBlue300, + bgCanvasDefault = DarkColorTokens.colorThemeBg, + bgCanvasDefaultLevel1 = DarkColorTokens.colorGray300, + bgCanvasDisabled = DarkColorTokens.colorGray200, + bgCriticalHovered = DarkColorTokens.colorRed1000, + bgCriticalPrimary = DarkColorTokens.colorRed900, + bgCriticalSubtle = DarkColorTokens.colorRed200, + bgCriticalSubtleHovered = DarkColorTokens.colorRed300, + bgDecorative1 = DarkColorTokens.colorLime300, + bgDecorative2 = DarkColorTokens.colorCyan300, + bgDecorative3 = DarkColorTokens.colorFuchsia300, + bgDecorative4 = DarkColorTokens.colorPurple300, + bgDecorative5 = DarkColorTokens.colorPink300, + bgDecorative6 = DarkColorTokens.colorOrange300, + bgInfoSubtle = DarkColorTokens.colorBlue200, + bgSubtlePrimary = DarkColorTokens.colorGray400, + bgSubtleSecondary = DarkColorTokens.colorGray300, + bgSubtleSecondaryLevel0 = DarkColorTokens.colorThemeBg, + bgSuccessSubtle = DarkColorTokens.colorGreen200, + borderAccentSubtle = DarkColorTokens.colorGreen700, + borderCriticalHovered = DarkColorTokens.colorRed1000, + borderCriticalPrimary = DarkColorTokens.colorRed900, + borderCriticalSubtle = DarkColorTokens.colorRed500, + borderDisabled = DarkColorTokens.colorGray500, + borderFocused = DarkColorTokens.colorBlue900, + borderInfoSubtle = DarkColorTokens.colorBlue700, + borderInteractiveHovered = DarkColorTokens.colorGray1100, + borderInteractivePrimary = DarkColorTokens.colorGray800, + borderInteractiveSecondary = DarkColorTokens.colorGray600, + borderSuccessSubtle = DarkColorTokens.colorGreen500, + gradientActionStop1 = DarkColorTokens.colorGreen1100, + gradientActionStop2 = DarkColorTokens.colorGreen900, + gradientActionStop3 = DarkColorTokens.colorGreen700, + gradientActionStop4 = DarkColorTokens.colorGreen500, + gradientInfoStop1 = DarkColorTokens.colorAlphaBlue500, + gradientInfoStop2 = DarkColorTokens.colorAlphaBlue400, + gradientInfoStop3 = DarkColorTokens.colorAlphaBlue300, + gradientInfoStop4 = DarkColorTokens.colorAlphaBlue200, + gradientInfoStop5 = DarkColorTokens.colorAlphaBlue100, + gradientInfoStop6 = DarkColorTokens.colorTransparent, + gradientSubtleStop1 = DarkColorTokens.colorAlphaGreen500, + gradientSubtleStop2 = DarkColorTokens.colorAlphaGreen400, + gradientSubtleStop3 = DarkColorTokens.colorAlphaGreen300, + gradientSubtleStop4 = DarkColorTokens.colorAlphaGreen200, + gradientSubtleStop5 = DarkColorTokens.colorAlphaGreen100, + gradientSubtleStop6 = DarkColorTokens.colorTransparent, + iconAccentPrimary = DarkColorTokens.colorGreen900, + iconAccentTertiary = DarkColorTokens.colorGreen800, + iconCriticalPrimary = DarkColorTokens.colorRed900, + iconDisabled = DarkColorTokens.colorGray700, + iconInfoPrimary = DarkColorTokens.colorBlue900, + iconOnSolidPrimary = DarkColorTokens.colorThemeBg, + iconPrimary = DarkColorTokens.colorGray1400, + iconPrimaryAlpha = DarkColorTokens.colorAlphaGray1400, + iconQuaternary = DarkColorTokens.colorGray700, + iconQuaternaryAlpha = DarkColorTokens.colorAlphaGray700, + iconSecondary = DarkColorTokens.colorGray900, + iconSecondaryAlpha = DarkColorTokens.colorAlphaGray900, + iconSuccessPrimary = DarkColorTokens.colorGreen900, + iconTertiary = DarkColorTokens.colorGray800, + iconTertiaryAlpha = DarkColorTokens.colorAlphaGray800, + textActionAccent = DarkColorTokens.colorGreen900, + textActionPrimary = DarkColorTokens.colorGray1400, + textBadgeAccent = DarkColorTokens.colorGreen1100, + textBadgeInfo = DarkColorTokens.colorBlue1100, + textCriticalPrimary = DarkColorTokens.colorRed900, + textDecorative1 = DarkColorTokens.colorLime1100, + textDecorative2 = DarkColorTokens.colorCyan1100, + textDecorative3 = DarkColorTokens.colorFuchsia1100, + textDecorative4 = DarkColorTokens.colorPurple1100, + textDecorative5 = DarkColorTokens.colorPink1100, + textDecorative6 = DarkColorTokens.colorOrange1100, + textDisabled = DarkColorTokens.colorGray800, + textInfoPrimary = DarkColorTokens.colorBlue900, + textLinkExternal = DarkColorTokens.colorBlue900, + textOnSolidPrimary = DarkColorTokens.colorThemeBg, + textPrimary = DarkColorTokens.colorGray1400, + textSecondary = DarkColorTokens.colorGray900, + textSuccessPrimary = DarkColorTokens.colorGreen900, + isLight = false, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDarkHc.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDarkHc.kt new file mode 100644 index 0000000000..88d2ef3abe --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsDarkHc.kt @@ -0,0 +1,121 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.internal.DarkHcColorTokens + +/** + * Semantic colors for the high contrast dark Compound theme. + */ +@OptIn(CoreColorToken::class) +val compoundColorsHcDark = SemanticColors( + bgAccentHovered = DarkHcColorTokens.colorGreen1000, + bgAccentPressed = DarkHcColorTokens.colorGreen1100, + bgAccentRest = DarkHcColorTokens.colorGreen900, + bgAccentSelected = DarkHcColorTokens.colorAlphaGreen300, + bgActionPrimaryDisabled = DarkHcColorTokens.colorGray700, + bgActionPrimaryHovered = DarkHcColorTokens.colorGray1200, + bgActionPrimaryPressed = DarkHcColorTokens.colorGray1100, + bgActionPrimaryRest = DarkHcColorTokens.colorGray1400, + bgActionSecondaryHovered = DarkHcColorTokens.colorAlphaGray200, + bgActionSecondaryPressed = DarkHcColorTokens.colorAlphaGray300, + bgActionSecondaryRest = DarkHcColorTokens.colorThemeBg, + bgBadgeAccent = DarkHcColorTokens.colorAlphaGreen300, + bgBadgeDefault = DarkHcColorTokens.colorAlphaGray300, + bgBadgeInfo = DarkHcColorTokens.colorAlphaBlue300, + bgCanvasDefault = DarkHcColorTokens.colorThemeBg, + bgCanvasDefaultLevel1 = DarkHcColorTokens.colorGray300, + bgCanvasDisabled = DarkHcColorTokens.colorGray200, + bgCriticalHovered = DarkHcColorTokens.colorRed1000, + bgCriticalPrimary = DarkHcColorTokens.colorRed900, + bgCriticalSubtle = DarkHcColorTokens.colorRed200, + bgCriticalSubtleHovered = DarkHcColorTokens.colorRed300, + bgDecorative1 = DarkHcColorTokens.colorLime300, + bgDecorative2 = DarkHcColorTokens.colorCyan300, + bgDecorative3 = DarkHcColorTokens.colorFuchsia300, + bgDecorative4 = DarkHcColorTokens.colorPurple300, + bgDecorative5 = DarkHcColorTokens.colorPink300, + bgDecorative6 = DarkHcColorTokens.colorOrange300, + bgInfoSubtle = DarkHcColorTokens.colorBlue200, + bgSubtlePrimary = DarkHcColorTokens.colorGray400, + bgSubtleSecondary = DarkHcColorTokens.colorGray300, + bgSubtleSecondaryLevel0 = DarkHcColorTokens.colorThemeBg, + bgSuccessSubtle = DarkHcColorTokens.colorGreen200, + borderAccentSubtle = DarkHcColorTokens.colorGreen700, + borderCriticalHovered = DarkHcColorTokens.colorRed1000, + borderCriticalPrimary = DarkHcColorTokens.colorRed900, + borderCriticalSubtle = DarkHcColorTokens.colorRed500, + borderDisabled = DarkHcColorTokens.colorGray500, + borderFocused = DarkHcColorTokens.colorBlue900, + borderInfoSubtle = DarkHcColorTokens.colorBlue700, + borderInteractiveHovered = DarkHcColorTokens.colorGray1100, + borderInteractivePrimary = DarkHcColorTokens.colorGray800, + borderInteractiveSecondary = DarkHcColorTokens.colorGray600, + borderSuccessSubtle = DarkHcColorTokens.colorGreen500, + gradientActionStop1 = DarkHcColorTokens.colorGreen1100, + gradientActionStop2 = DarkHcColorTokens.colorGreen900, + gradientActionStop3 = DarkHcColorTokens.colorGreen700, + gradientActionStop4 = DarkHcColorTokens.colorGreen500, + gradientInfoStop1 = DarkHcColorTokens.colorAlphaBlue500, + gradientInfoStop2 = DarkHcColorTokens.colorAlphaBlue400, + gradientInfoStop3 = DarkHcColorTokens.colorAlphaBlue300, + gradientInfoStop4 = DarkHcColorTokens.colorAlphaBlue200, + gradientInfoStop5 = DarkHcColorTokens.colorAlphaBlue100, + gradientInfoStop6 = DarkHcColorTokens.colorTransparent, + gradientSubtleStop1 = DarkHcColorTokens.colorAlphaGreen500, + gradientSubtleStop2 = DarkHcColorTokens.colorAlphaGreen400, + gradientSubtleStop3 = DarkHcColorTokens.colorAlphaGreen300, + gradientSubtleStop4 = DarkHcColorTokens.colorAlphaGreen200, + gradientSubtleStop5 = DarkHcColorTokens.colorAlphaGreen100, + gradientSubtleStop6 = DarkHcColorTokens.colorTransparent, + iconAccentPrimary = DarkHcColorTokens.colorGreen900, + iconAccentTertiary = DarkHcColorTokens.colorGreen800, + iconCriticalPrimary = DarkHcColorTokens.colorRed900, + iconDisabled = DarkHcColorTokens.colorGray700, + iconInfoPrimary = DarkHcColorTokens.colorBlue900, + iconOnSolidPrimary = DarkHcColorTokens.colorThemeBg, + iconPrimary = DarkHcColorTokens.colorGray1400, + iconPrimaryAlpha = DarkHcColorTokens.colorAlphaGray1400, + iconQuaternary = DarkHcColorTokens.colorGray700, + iconQuaternaryAlpha = DarkHcColorTokens.colorAlphaGray700, + iconSecondary = DarkHcColorTokens.colorGray900, + iconSecondaryAlpha = DarkHcColorTokens.colorAlphaGray900, + iconSuccessPrimary = DarkHcColorTokens.colorGreen900, + iconTertiary = DarkHcColorTokens.colorGray800, + iconTertiaryAlpha = DarkHcColorTokens.colorAlphaGray800, + textActionAccent = DarkHcColorTokens.colorGreen900, + textActionPrimary = DarkHcColorTokens.colorGray1400, + textBadgeAccent = DarkHcColorTokens.colorGreen1100, + textBadgeInfo = DarkHcColorTokens.colorBlue1100, + textCriticalPrimary = DarkHcColorTokens.colorRed900, + textDecorative1 = DarkHcColorTokens.colorLime1100, + textDecorative2 = DarkHcColorTokens.colorCyan1100, + textDecorative3 = DarkHcColorTokens.colorFuchsia1100, + textDecorative4 = DarkHcColorTokens.colorPurple1100, + textDecorative5 = DarkHcColorTokens.colorPink1100, + textDecorative6 = DarkHcColorTokens.colorOrange1100, + textDisabled = DarkHcColorTokens.colorGray800, + textInfoPrimary = DarkHcColorTokens.colorBlue900, + textLinkExternal = DarkHcColorTokens.colorBlue900, + textOnSolidPrimary = DarkHcColorTokens.colorThemeBg, + textPrimary = DarkHcColorTokens.colorGray1400, + textSecondary = DarkHcColorTokens.colorGray900, + textSuccessPrimary = DarkHcColorTokens.colorGreen900, + isLight = false, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLight.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLight.kt new file mode 100644 index 0000000000..03173ad24e --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLight.kt @@ -0,0 +1,121 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.internal.LightColorTokens + +/** + * Semantic colors for the light Compound theme. + */ +@OptIn(CoreColorToken::class) +val compoundColorsLight = SemanticColors( + bgAccentHovered = LightColorTokens.colorGreen1000, + bgAccentPressed = LightColorTokens.colorGreen1100, + bgAccentRest = LightColorTokens.colorGreen900, + bgAccentSelected = LightColorTokens.colorAlphaGreen300, + bgActionPrimaryDisabled = LightColorTokens.colorGray700, + bgActionPrimaryHovered = LightColorTokens.colorGray1200, + bgActionPrimaryPressed = LightColorTokens.colorGray1100, + bgActionPrimaryRest = LightColorTokens.colorGray1400, + bgActionSecondaryHovered = LightColorTokens.colorAlphaGray200, + bgActionSecondaryPressed = LightColorTokens.colorAlphaGray300, + bgActionSecondaryRest = LightColorTokens.colorThemeBg, + bgBadgeAccent = LightColorTokens.colorAlphaGreen300, + bgBadgeDefault = LightColorTokens.colorAlphaGray300, + bgBadgeInfo = LightColorTokens.colorAlphaBlue300, + bgCanvasDefault = LightColorTokens.colorThemeBg, + bgCanvasDefaultLevel1 = LightColorTokens.colorThemeBg, + bgCanvasDisabled = LightColorTokens.colorGray200, + bgCriticalHovered = LightColorTokens.colorRed1000, + bgCriticalPrimary = LightColorTokens.colorRed900, + bgCriticalSubtle = LightColorTokens.colorRed200, + bgCriticalSubtleHovered = LightColorTokens.colorRed300, + bgDecorative1 = LightColorTokens.colorLime300, + bgDecorative2 = LightColorTokens.colorCyan300, + bgDecorative3 = LightColorTokens.colorFuchsia300, + bgDecorative4 = LightColorTokens.colorPurple300, + bgDecorative5 = LightColorTokens.colorPink300, + bgDecorative6 = LightColorTokens.colorOrange300, + bgInfoSubtle = LightColorTokens.colorBlue200, + bgSubtlePrimary = LightColorTokens.colorGray400, + bgSubtleSecondary = LightColorTokens.colorGray300, + bgSubtleSecondaryLevel0 = LightColorTokens.colorGray300, + bgSuccessSubtle = LightColorTokens.colorGreen200, + borderAccentSubtle = LightColorTokens.colorGreen700, + borderCriticalHovered = LightColorTokens.colorRed1000, + borderCriticalPrimary = LightColorTokens.colorRed900, + borderCriticalSubtle = LightColorTokens.colorRed500, + borderDisabled = LightColorTokens.colorGray500, + borderFocused = LightColorTokens.colorBlue900, + borderInfoSubtle = LightColorTokens.colorBlue700, + borderInteractiveHovered = LightColorTokens.colorGray1100, + borderInteractivePrimary = LightColorTokens.colorGray800, + borderInteractiveSecondary = LightColorTokens.colorGray600, + borderSuccessSubtle = LightColorTokens.colorGreen500, + gradientActionStop1 = LightColorTokens.colorGreen500, + gradientActionStop2 = LightColorTokens.colorGreen700, + gradientActionStop3 = LightColorTokens.colorGreen900, + gradientActionStop4 = LightColorTokens.colorGreen1100, + gradientInfoStop1 = LightColorTokens.colorAlphaBlue500, + gradientInfoStop2 = LightColorTokens.colorAlphaBlue400, + gradientInfoStop3 = LightColorTokens.colorAlphaBlue300, + gradientInfoStop4 = LightColorTokens.colorAlphaBlue200, + gradientInfoStop5 = LightColorTokens.colorAlphaBlue100, + gradientInfoStop6 = LightColorTokens.colorTransparent, + gradientSubtleStop1 = LightColorTokens.colorAlphaGreen500, + gradientSubtleStop2 = LightColorTokens.colorAlphaGreen400, + gradientSubtleStop3 = LightColorTokens.colorAlphaGreen300, + gradientSubtleStop4 = LightColorTokens.colorAlphaGreen200, + gradientSubtleStop5 = LightColorTokens.colorAlphaGreen100, + gradientSubtleStop6 = LightColorTokens.colorTransparent, + iconAccentPrimary = LightColorTokens.colorGreen900, + iconAccentTertiary = LightColorTokens.colorGreen800, + iconCriticalPrimary = LightColorTokens.colorRed900, + iconDisabled = LightColorTokens.colorGray700, + iconInfoPrimary = LightColorTokens.colorBlue900, + iconOnSolidPrimary = LightColorTokens.colorThemeBg, + iconPrimary = LightColorTokens.colorGray1400, + iconPrimaryAlpha = LightColorTokens.colorAlphaGray1400, + iconQuaternary = LightColorTokens.colorGray700, + iconQuaternaryAlpha = LightColorTokens.colorAlphaGray700, + iconSecondary = LightColorTokens.colorGray900, + iconSecondaryAlpha = LightColorTokens.colorAlphaGray900, + iconSuccessPrimary = LightColorTokens.colorGreen900, + iconTertiary = LightColorTokens.colorGray800, + iconTertiaryAlpha = LightColorTokens.colorAlphaGray800, + textActionAccent = LightColorTokens.colorGreen900, + textActionPrimary = LightColorTokens.colorGray1400, + textBadgeAccent = LightColorTokens.colorGreen1100, + textBadgeInfo = LightColorTokens.colorBlue1100, + textCriticalPrimary = LightColorTokens.colorRed900, + textDecorative1 = LightColorTokens.colorLime1100, + textDecorative2 = LightColorTokens.colorCyan1100, + textDecorative3 = LightColorTokens.colorFuchsia1100, + textDecorative4 = LightColorTokens.colorPurple1100, + textDecorative5 = LightColorTokens.colorPink1100, + textDecorative6 = LightColorTokens.colorOrange1100, + textDisabled = LightColorTokens.colorGray800, + textInfoPrimary = LightColorTokens.colorBlue900, + textLinkExternal = LightColorTokens.colorBlue900, + textOnSolidPrimary = LightColorTokens.colorThemeBg, + textPrimary = LightColorTokens.colorGray1400, + textSecondary = LightColorTokens.colorGray900, + textSuccessPrimary = LightColorTokens.colorGreen900, + isLight = true, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLightHc.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLightHc.kt new file mode 100644 index 0000000000..00100f7ea8 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/SemanticColorsLightHc.kt @@ -0,0 +1,121 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import io.element.android.compound.annotations.CoreColorToken +import io.element.android.compound.tokens.generated.internal.LightHcColorTokens + +/** + * Semantic colors for the high contrast light Compound theme. + */ +@OptIn(CoreColorToken::class) +val compoundColorsHcLight = SemanticColors( + bgAccentHovered = LightHcColorTokens.colorGreen1000, + bgAccentPressed = LightHcColorTokens.colorGreen1100, + bgAccentRest = LightHcColorTokens.colorGreen900, + bgAccentSelected = LightHcColorTokens.colorAlphaGreen300, + bgActionPrimaryDisabled = LightHcColorTokens.colorGray700, + bgActionPrimaryHovered = LightHcColorTokens.colorGray1200, + bgActionPrimaryPressed = LightHcColorTokens.colorGray1100, + bgActionPrimaryRest = LightHcColorTokens.colorGray1400, + bgActionSecondaryHovered = LightHcColorTokens.colorAlphaGray200, + bgActionSecondaryPressed = LightHcColorTokens.colorAlphaGray300, + bgActionSecondaryRest = LightHcColorTokens.colorThemeBg, + bgBadgeAccent = LightHcColorTokens.colorAlphaGreen300, + bgBadgeDefault = LightHcColorTokens.colorAlphaGray300, + bgBadgeInfo = LightHcColorTokens.colorAlphaBlue300, + bgCanvasDefault = LightHcColorTokens.colorThemeBg, + bgCanvasDefaultLevel1 = LightHcColorTokens.colorThemeBg, + bgCanvasDisabled = LightHcColorTokens.colorGray200, + bgCriticalHovered = LightHcColorTokens.colorRed1000, + bgCriticalPrimary = LightHcColorTokens.colorRed900, + bgCriticalSubtle = LightHcColorTokens.colorRed200, + bgCriticalSubtleHovered = LightHcColorTokens.colorRed300, + bgDecorative1 = LightHcColorTokens.colorLime300, + bgDecorative2 = LightHcColorTokens.colorCyan300, + bgDecorative3 = LightHcColorTokens.colorFuchsia300, + bgDecorative4 = LightHcColorTokens.colorPurple300, + bgDecorative5 = LightHcColorTokens.colorPink300, + bgDecorative6 = LightHcColorTokens.colorOrange300, + bgInfoSubtle = LightHcColorTokens.colorBlue200, + bgSubtlePrimary = LightHcColorTokens.colorGray400, + bgSubtleSecondary = LightHcColorTokens.colorGray300, + bgSubtleSecondaryLevel0 = LightHcColorTokens.colorGray300, + bgSuccessSubtle = LightHcColorTokens.colorGreen200, + borderAccentSubtle = LightHcColorTokens.colorGreen700, + borderCriticalHovered = LightHcColorTokens.colorRed1000, + borderCriticalPrimary = LightHcColorTokens.colorRed900, + borderCriticalSubtle = LightHcColorTokens.colorRed500, + borderDisabled = LightHcColorTokens.colorGray500, + borderFocused = LightHcColorTokens.colorBlue900, + borderInfoSubtle = LightHcColorTokens.colorBlue700, + borderInteractiveHovered = LightHcColorTokens.colorGray1100, + borderInteractivePrimary = LightHcColorTokens.colorGray800, + borderInteractiveSecondary = LightHcColorTokens.colorGray600, + borderSuccessSubtle = LightHcColorTokens.colorGreen500, + gradientActionStop1 = LightHcColorTokens.colorGreen500, + gradientActionStop2 = LightHcColorTokens.colorGreen700, + gradientActionStop3 = LightHcColorTokens.colorGreen900, + gradientActionStop4 = LightHcColorTokens.colorGreen1100, + gradientInfoStop1 = LightHcColorTokens.colorAlphaBlue500, + gradientInfoStop2 = LightHcColorTokens.colorAlphaBlue400, + gradientInfoStop3 = LightHcColorTokens.colorAlphaBlue300, + gradientInfoStop4 = LightHcColorTokens.colorAlphaBlue200, + gradientInfoStop5 = LightHcColorTokens.colorAlphaBlue100, + gradientInfoStop6 = LightHcColorTokens.colorTransparent, + gradientSubtleStop1 = LightHcColorTokens.colorAlphaGreen500, + gradientSubtleStop2 = LightHcColorTokens.colorAlphaGreen400, + gradientSubtleStop3 = LightHcColorTokens.colorAlphaGreen300, + gradientSubtleStop4 = LightHcColorTokens.colorAlphaGreen200, + gradientSubtleStop5 = LightHcColorTokens.colorAlphaGreen100, + gradientSubtleStop6 = LightHcColorTokens.colorTransparent, + iconAccentPrimary = LightHcColorTokens.colorGreen900, + iconAccentTertiary = LightHcColorTokens.colorGreen800, + iconCriticalPrimary = LightHcColorTokens.colorRed900, + iconDisabled = LightHcColorTokens.colorGray700, + iconInfoPrimary = LightHcColorTokens.colorBlue900, + iconOnSolidPrimary = LightHcColorTokens.colorThemeBg, + iconPrimary = LightHcColorTokens.colorGray1400, + iconPrimaryAlpha = LightHcColorTokens.colorAlphaGray1400, + iconQuaternary = LightHcColorTokens.colorGray700, + iconQuaternaryAlpha = LightHcColorTokens.colorAlphaGray700, + iconSecondary = LightHcColorTokens.colorGray900, + iconSecondaryAlpha = LightHcColorTokens.colorAlphaGray900, + iconSuccessPrimary = LightHcColorTokens.colorGreen900, + iconTertiary = LightHcColorTokens.colorGray800, + iconTertiaryAlpha = LightHcColorTokens.colorAlphaGray800, + textActionAccent = LightHcColorTokens.colorGreen900, + textActionPrimary = LightHcColorTokens.colorGray1400, + textBadgeAccent = LightHcColorTokens.colorGreen1100, + textBadgeInfo = LightHcColorTokens.colorBlue1100, + textCriticalPrimary = LightHcColorTokens.colorRed900, + textDecorative1 = LightHcColorTokens.colorLime1100, + textDecorative2 = LightHcColorTokens.colorCyan1100, + textDecorative3 = LightHcColorTokens.colorFuchsia1100, + textDecorative4 = LightHcColorTokens.colorPurple1100, + textDecorative5 = LightHcColorTokens.colorPink1100, + textDecorative6 = LightHcColorTokens.colorOrange1100, + textDisabled = LightHcColorTokens.colorGray800, + textInfoPrimary = LightHcColorTokens.colorBlue900, + textLinkExternal = LightHcColorTokens.colorBlue900, + textOnSolidPrimary = LightHcColorTokens.colorThemeBg, + textPrimary = LightHcColorTokens.colorGray1400, + textSecondary = LightHcColorTokens.colorGray900, + textSuccessPrimary = LightHcColorTokens.colorGreen900, + isLight = true, +) diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/TypographyTokens.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/TypographyTokens.kt new file mode 100644 index 0000000000..a25b79234c --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/TypographyTokens.kt @@ -0,0 +1,174 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated + +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.unit.em +import androidx.compose.ui.unit.sp +import androidx.compose.ui.text.PlatformTextStyle +import androidx.compose.ui.text.style.LineHeightStyle + +object TypographyTokens { + val fontBodyLgMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W500, + lineHeight = 22.sp, + fontSize = 16.sp, + letterSpacing = 0.015625.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodyLgRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 22.sp, + fontSize = 16.sp, + letterSpacing = 0.015625.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodyMdMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W500, + lineHeight = 20.sp, + fontSize = 14.sp, + letterSpacing = 0.017857.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodyMdRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 20.sp, + fontSize = 14.sp, + letterSpacing = 0.017857.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodySmMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W500, + lineHeight = 17.sp, + fontSize = 12.sp, + letterSpacing = 0.033333.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodySmRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 17.sp, + fontSize = 12.sp, + letterSpacing = 0.033333.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodyXsMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W500, + lineHeight = 15.sp, + fontSize = 11.sp, + letterSpacing = 0.045454.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontBodyXsRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 15.sp, + fontSize = 11.sp, + letterSpacing = 0.045454.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingLgBold = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W700, + lineHeight = 34.sp, + fontSize = 28.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingLgRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 34.sp, + fontSize = 28.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingMdBold = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W700, + lineHeight = 27.sp, + fontSize = 22.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingMdRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 27.sp, + fontSize = 22.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingSmMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W500, + lineHeight = 25.sp, + fontSize = 20.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingSmRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 25.sp, + fontSize = 20.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingXlBold = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W700, + lineHeight = 41.sp, + fontSize = 34.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) + val fontHeadingXlRegular = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.W400, + lineHeight = 41.sp, + fontSize = 34.sp, + letterSpacing = 0.em, + platformStyle = PlatformTextStyle(includeFontPadding = false), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None) + ) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkColorTokens.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkColorTokens.kt new file mode 100644 index 0000000000..1272c0df16 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkColorTokens.kt @@ -0,0 +1,335 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated.internal + +import androidx.compose.ui.graphics.Color +import io.element.android.compound.annotations.CoreColorToken + +@CoreColorToken +object DarkColorTokens { + val colorAlphaBlue100 = Color(0xff00055c) + val colorAlphaBlue1000 = Color(0xf062a0fe) + val colorAlphaBlue1100 = Color(0xf57cb2fd) + val colorAlphaBlue1200 = Color(0xf7a3c8ff) + val colorAlphaBlue1300 = Color(0xfccde1fe) + val colorAlphaBlue1400 = Color(0xffe6effe) + val colorAlphaBlue200 = Color(0xff00095c) + val colorAlphaBlue300 = Color(0xff001366) + val colorAlphaBlue400 = Color(0xff001e70) + val colorAlphaBlue500 = Color(0xa1003cbd) + val colorAlphaBlue600 = Color(0x87015afe) + val colorAlphaBlue700 = Color(0xa30665fe) + val colorAlphaBlue800 = Color(0xd61077fe) + val colorAlphaBlue900 = Color(0xeb4491fd) + val colorAlphaCyan100 = Color(0xff001142) + val colorAlphaCyan1000 = Color(0xe000bfe0) + val colorAlphaCyan1100 = Color(0xc926e7fd) + val colorAlphaCyan1200 = Color(0xd98af1ff) + val colorAlphaCyan1300 = Color(0xebc9f7fd) + val colorAlphaCyan1400 = Color(0xf5e1fbfe) + val colorAlphaCyan200 = Color(0xff001447) + val colorAlphaCyan300 = Color(0xff001b4d) + val colorAlphaCyan400 = Color(0xff00265c) + val colorAlphaCyan500 = Color(0xff003366) + val colorAlphaCyan600 = Color(0xff003f75) + val colorAlphaCyan700 = Color(0xff00538a) + val colorAlphaCyan800 = Color(0xe0007ebd) + val colorAlphaCyan900 = Color(0xff0091bd) + val colorAlphaFuchsia100 = Color(0xff28003d) + val colorAlphaFuchsia1000 = Color(0xd4f790fe) + val colorAlphaFuchsia1100 = Color(0xdbfaa4fe) + val colorAlphaFuchsia1200 = Color(0xe8fac3fe) + val colorAlphaFuchsia1300 = Color(0xf2fde0ff) + val colorAlphaFuchsia1400 = Color(0xfafdecfe) + val colorAlphaFuchsia200 = Color(0xff2d0042) + val colorAlphaFuchsia300 = Color(0xff36004d) + val colorAlphaFuchsia400 = Color(0xff45005c) + val colorAlphaFuchsia500 = Color(0x61ca0aff) + val colorAlphaFuchsia600 = Color(0x70d21fff) + val colorAlphaFuchsia700 = Color(0x8ad82ffe) + val colorAlphaFuchsia800 = Color(0xb5eb44fd) + val colorAlphaFuchsia900 = Color(0xccf172fd) + val colorAlphaGray100 = Color(0x05d8dbdf) + val colorAlphaGray1000 = Color(0x9ce1eefe) + val colorAlphaGray1100 = Color(0xade7f0fe) + val colorAlphaGray1200 = Color(0xc9edf4fc) + val colorAlphaGray1300 = Color(0xe3f2f7fd) + val colorAlphaGray1400 = Color(0xf2f6f9fe) + val colorAlphaGray200 = Color(0x0ad9c3df) + val colorAlphaGray300 = Color(0x0fe9dbf0) + val colorAlphaGray400 = Color(0x1aede7f4) + val colorAlphaGray500 = Color(0x26f4f7fa) + val colorAlphaGray600 = Color(0x33eceff8) + val colorAlphaGray700 = Color(0x45e7f1fd) + val colorAlphaGray800 = Color(0x69e0edff) + val colorAlphaGray900 = Color(0x8ae1effe) + val colorAlphaGreen100 = Color(0xff001f0c) + val colorAlphaGreen1000 = Color(0xa61bfebd) + val colorAlphaGreen1100 = Color(0xbd26fdbc) + val colorAlphaGreen1200 = Color(0xd486fdce) + val colorAlphaGreen1300 = Color(0xe8c4fde2) + val colorAlphaGreen1400 = Color(0xf5e2fdf1) + val colorAlphaGreen200 = Color(0xff001f0e) + val colorAlphaGreen300 = Color(0xff002412) + val colorAlphaGreen400 = Color(0xff002e1b) + val colorAlphaGreen500 = Color(0xff003d29) + val colorAlphaGreen600 = Color(0xff004732) + val colorAlphaGreen700 = Color(0xff005c45) + val colorAlphaGreen800 = Color(0xff007a62) + val colorAlphaGreen900 = Color(0x9412fdbe) + val colorAlphaLime100 = Color(0xff001a00) + val colorAlphaLime1000 = Color(0xa860fc2c) + val colorAlphaLime1100 = Color(0xbd71fd35) + val colorAlphaLime1200 = Color(0xd68dff5c) + val colorAlphaLime1300 = Color(0xebc3ffad) + val colorAlphaLime1400 = Color(0xf7e1fdd8) + val colorAlphaLime200 = Color(0xff001f00) + val colorAlphaLime300 = Color(0xff002900) + val colorAlphaLime400 = Color(0xff002e00) + val colorAlphaLime500 = Color(0xff003d00) + val colorAlphaLime600 = Color(0xff004d00) + val colorAlphaLime700 = Color(0xff005c00) + val colorAlphaLime800 = Color(0x732dfd0d) + val colorAlphaLime900 = Color(0x9454fd26) + val colorAlphaOrange100 = Color(0xff380000) + val colorAlphaOrange1000 = Color(0xebfe8310) + val colorAlphaOrange1100 = Color(0xf7fd953f) + val colorAlphaOrange1200 = Color(0xfcfdb781) + val colorAlphaOrange1300 = Color(0xffffd4b8) + val colorAlphaOrange1400 = Color(0xffffeadb) + val colorAlphaOrange200 = Color(0xff3d0000) + val colorAlphaOrange300 = Color(0xff470000) + val colorAlphaOrange400 = Color(0xff570000) + val colorAlphaOrange500 = Color(0xff700000) + val colorAlphaOrange600 = Color(0xff850400) + val colorAlphaOrange700 = Color(0xbdc72800) + val colorAlphaOrange800 = Color(0xb5ff5900) + val colorAlphaOrange900 = Color(0xd9fe740b) + val colorAlphaPink100 = Color(0xff38000f) + val colorAlphaPink1000 = Color(0xfaff6691) + val colorAlphaPink1100 = Color(0xfffe86a4) + val colorAlphaPink1200 = Color(0xffffadc0) + val colorAlphaPink1300 = Color(0xffffd1db) + val colorAlphaPink1400 = Color(0xffffebef) + val colorAlphaPink200 = Color(0xff3d0012) + val colorAlphaPink300 = Color(0xff470019) + val colorAlphaPink400 = Color(0xff570024) + val colorAlphaPink500 = Color(0xff6b0036) + val colorAlphaPink600 = Color(0x75fb0473) + val colorAlphaPink700 = Color(0x94fd1277) + val colorAlphaPink800 = Color(0xccfe1b79) + val colorAlphaPink900 = Color(0xf5fe4382) + val colorAlphaPurple100 = Color(0xff1a0057) + val colorAlphaPurple1000 = Color(0xfca28bfe) + val colorAlphaPurple1100 = Color(0xffab9afe) + val colorAlphaPurple1200 = Color(0xffc7bdff) + val colorAlphaPurple1300 = Color(0xffdfdbff) + val colorAlphaPurple1400 = Color(0xffeeebff) + val colorAlphaPurple200 = Color(0xff1d005c) + val colorAlphaPurple300 = Color(0xff22006b) + val colorAlphaPurple400 = Color(0xff2d0080) + val colorAlphaPurple500 = Color(0xff3d009e) + val colorAlphaPurple600 = Color(0xab690dfd) + val colorAlphaPurple700 = Color(0xc2712bfd) + val colorAlphaPurple800 = Color(0xeb7f4dff) + val colorAlphaPurple900 = Color(0xfa9271fe) + val colorAlphaRed100 = Color(0xff380000) + val colorAlphaRed1000 = Color(0xffff645c) + val colorAlphaRed1100 = Color(0xffff857a) + val colorAlphaRed1200 = Color(0xffffaea3) + val colorAlphaRed1300 = Color(0xffffd3cc) + val colorAlphaRed1400 = Color(0xffffe8e5) + val colorAlphaRed200 = Color(0xff3d0000) + val colorAlphaRed300 = Color(0xff470000) + val colorAlphaRed400 = Color(0xff5c0000) + val colorAlphaRed500 = Color(0xff700000) + val colorAlphaRed600 = Color(0xff850009) + val colorAlphaRed700 = Color(0x99fe0b24) + val colorAlphaRed800 = Color(0xcffe2530) + val colorAlphaRed900 = Color(0xfffd3d3a) + val colorAlphaYellow100 = Color(0xff380000) + val colorAlphaYellow1000 = Color(0xffcc8b00) + val colorAlphaYellow1100 = Color(0xffdba100) + val colorAlphaYellow1200 = Color(0xf0fdc50d) + val colorAlphaYellow1300 = Color(0xfffeda58) + val colorAlphaYellow1400 = Color(0xffffedb3) + val colorAlphaYellow200 = Color(0xff380300) + val colorAlphaYellow300 = Color(0xff420900) + val colorAlphaYellow400 = Color(0xff4d1400) + val colorAlphaYellow500 = Color(0xff5c2300) + val colorAlphaYellow600 = Color(0xde753300) + val colorAlphaYellow700 = Color(0xeb854200) + val colorAlphaYellow800 = Color(0xff9e5c00) + val colorAlphaYellow900 = Color(0xffbd7b00) + val colorBlue100 = Color(0xff00055a) + val colorBlue1000 = Color(0xff5e99f0) + val colorBlue1100 = Color(0xff7aacf4) + val colorBlue1200 = Color(0xffa1c4f8) + val colorBlue1300 = Color(0xffcbdffc) + val colorBlue1400 = Color(0xffe4eefe) + val colorBlue200 = Color(0xff00095d) + val colorBlue300 = Color(0xff001264) + val colorBlue400 = Color(0xff001e6f) + val colorBlue500 = Color(0xff062d80) + val colorBlue600 = Color(0xff083891) + val colorBlue700 = Color(0xff0b49ab) + val colorBlue800 = Color(0xff0e67d9) + val colorBlue900 = Color(0xff4187eb) + val colorCyan100 = Color(0xff001144) + val colorCyan1000 = Color(0xff02a7c6) + val colorCyan1100 = Color(0xff21bacd) + val colorCyan1200 = Color(0xff78d0dc) + val colorCyan1300 = Color(0xffb8e5eb) + val colorCyan1400 = Color(0xffdbf2f5) + val colorCyan200 = Color(0xff001448) + val colorCyan300 = Color(0xff001b4e) + val colorCyan400 = Color(0xff002559) + val colorCyan500 = Color(0xff003468) + val colorCyan600 = Color(0xff003f75) + val colorCyan700 = Color(0xff005188) + val colorCyan800 = Color(0xff0271aa) + val colorCyan900 = Color(0xff0093be) + val colorFuchsia100 = Color(0xff28003d) + val colorFuchsia1000 = Color(0xffcf78d7) + val colorFuchsia1100 = Color(0xffd991de) + val colorFuchsia1200 = Color(0xffe5b1e9) + val colorFuchsia1300 = Color(0xfff1d4f3) + val colorFuchsia1400 = Color(0xfff8e9f9) + val colorFuchsia200 = Color(0xff2e0044) + val colorFuchsia300 = Color(0xff37004e) + val colorFuchsia400 = Color(0xff46005e) + val colorFuchsia500 = Color(0xff560f6f) + val colorFuchsia600 = Color(0xff65177d) + val colorFuchsia700 = Color(0xff7d2394) + val colorFuchsia800 = Color(0xffaa36ba) + val colorFuchsia900 = Color(0xffc560cf) + val colorGray100 = Color(0xff14171b) + val colorGray1000 = Color(0xff9199a4) + val colorGray1100 = Color(0xffa3aab4) + val colorGray1200 = Color(0xffbdc3cc) + val colorGray1300 = Color(0xffd9dee4) + val colorGray1400 = Color(0xffebeef2) + val colorGray200 = Color(0xff181a1f) + val colorGray300 = Color(0xff1d1f24) + val colorGray400 = Color(0xff26282d) + val colorGray500 = Color(0xff323539) + val colorGray600 = Color(0xff3c3f44) + val colorGray700 = Color(0xff4a4f55) + val colorGray800 = Color(0xff656c76) + val colorGray900 = Color(0xff808994) + val colorGreen100 = Color(0xff001c0b) + val colorGreen1000 = Color(0xff17ac84) + val colorGreen1100 = Color(0xff1fc090) + val colorGreen1200 = Color(0xff72d5ae) + val colorGreen1300 = Color(0xffb5e8d1) + val colorGreen1400 = Color(0xffd9f4e7) + val colorGreen200 = Color(0xff001f0e) + val colorGreen300 = Color(0xff002513) + val colorGreen400 = Color(0xff002e1b) + val colorGreen500 = Color(0xff003d29) + val colorGreen600 = Color(0xff004832) + val colorGreen700 = Color(0xff005a43) + val colorGreen800 = Color(0xff007a62) + val colorGreen900 = Color(0xff129a78) + val colorLime100 = Color(0xff001b00) + val colorLime1000 = Color(0xff47ad26) + val colorLime1100 = Color(0xff56c02c) + val colorLime1200 = Color(0xff77d94f) + val colorLime1300 = Color(0xffb6eca3) + val colorLime1400 = Color(0xffdaf6d0) + val colorLime200 = Color(0xff002000) + val colorLime300 = Color(0xff002600) + val colorLime400 = Color(0xff003000) + val colorLime500 = Color(0xff003e00) + val colorLime600 = Color(0xff004a00) + val colorLime700 = Color(0xff005c00) + val colorLime800 = Color(0xff1d7c13) + val colorLime900 = Color(0xff389b20) + val colorOrange100 = Color(0xff380000) + val colorOrange1000 = Color(0xffeb7a12) + val colorOrange1100 = Color(0xfff6913d) + val colorOrange1200 = Color(0xfffbb37e) + val colorOrange1300 = Color(0xffffd5b9) + val colorOrange1400 = Color(0xffffeadb) + val colorOrange200 = Color(0xff3c0000) + val colorOrange300 = Color(0xff470000) + val colorOrange400 = Color(0xff580000) + val colorOrange500 = Color(0xff710000) + val colorOrange600 = Color(0xff830500) + val colorOrange700 = Color(0xff972206) + val colorOrange800 = Color(0xffb94607) + val colorOrange900 = Color(0xffda670d) + val colorPink100 = Color(0xff37000f) + val colorPink1000 = Color(0xfffa658f) + val colorPink1100 = Color(0xfffe84a2) + val colorPink1200 = Color(0xffffabbe) + val colorPink1300 = Color(0xffffd2dc) + val colorPink1400 = Color(0xffffe8ed) + val colorPink200 = Color(0xff3c0012) + val colorPink300 = Color(0xff450018) + val colorPink400 = Color(0xff550024) + val colorPink500 = Color(0xff6d0036) + val colorPink600 = Color(0xff7c0c41) + val colorPink700 = Color(0xff99114f) + val colorPink800 = Color(0xffce1865) + val colorPink900 = Color(0xfff4427d) + val colorPurple100 = Color(0xff1a0055) + val colorPurple1000 = Color(0xff9e87fc) + val colorPurple1100 = Color(0xffad9cfe) + val colorPurple1200 = Color(0xffc4baff) + val colorPurple1300 = Color(0xffdedaff) + val colorPurple1400 = Color(0xffeeebff) + val colorPurple200 = Color(0xff1c005a) + val colorPurple300 = Color(0xff22006a) + val colorPurple400 = Color(0xff2c0080) + val colorPurple500 = Color(0xff3d009e) + val colorPurple600 = Color(0xff4a0db1) + val colorPurple700 = Color(0xff5a27c6) + val colorPurple800 = Color(0xff7849ec) + val colorPurple900 = Color(0xff9171f9) + val colorRed100 = Color(0xff370000) + val colorRed1000 = Color(0xffff665d) + val colorRed1100 = Color(0xffff877c) + val colorRed1200 = Color(0xffffaea4) + val colorRed1300 = Color(0xffffd4cd) + val colorRed1400 = Color(0xffffe9e6) + val colorRed200 = Color(0xff3e0000) + val colorRed300 = Color(0xff470000) + val colorRed400 = Color(0xff590000) + val colorRed500 = Color(0xff710000) + val colorRed600 = Color(0xff830009) + val colorRed700 = Color(0xff9f0d1e) + val colorRed800 = Color(0xffd1212a) + val colorRed900 = Color(0xfffd3e3c) + val colorThemeBg = Color(0xff101317) + val colorTransparent = Color(0x00000000) + val colorYellow100 = Color(0xff360000) + val colorYellow1000 = Color(0xffcc8c00) + val colorYellow1100 = Color(0xffdb9f00) + val colorYellow1200 = Color(0xffefbb0b) + val colorYellow1300 = Color(0xfffedb58) + val colorYellow1400 = Color(0xffffedb1) + val colorYellow200 = Color(0xff3a0300) + val colorYellow300 = Color(0xff410900) + val colorYellow400 = Color(0xff4c1400) + val colorYellow500 = Color(0xff5c2400) + val colorYellow600 = Color(0xff682e03) + val colorYellow700 = Color(0xff7c3e02) + val colorYellow800 = Color(0xff9d5b00) + val colorYellow900 = Color(0xffbc7a00) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkHcColorTokens.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkHcColorTokens.kt new file mode 100644 index 0000000000..31406f6ffc --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/DarkHcColorTokens.kt @@ -0,0 +1,335 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated.internal + +import androidx.compose.ui.graphics.Color +import io.element.android.compound.annotations.CoreColorToken + +@CoreColorToken +object DarkHcColorTokens { + val colorAlphaBlue100 = Color(0xff00095c) + val colorAlphaBlue1000 = Color(0xf79ec5ff) + val colorAlphaBlue1100 = Color(0xfab8d4ff) + val colorAlphaBlue1200 = Color(0xfcc8defe) + val colorAlphaBlue1300 = Color(0xffe6effe) + val colorAlphaBlue1400 = Color(0xfff1f6fe) + val colorAlphaBlue200 = Color(0xff001366) + val colorAlphaBlue300 = Color(0xff001e70) + val colorAlphaBlue400 = Color(0xd1002b8f) + val colorAlphaBlue500 = Color(0x87015afe) + val colorAlphaBlue600 = Color(0xa30665fe) + val colorAlphaBlue700 = Color(0xcf0d71fd) + val colorAlphaBlue800 = Color(0xe83488fe) + val colorAlphaBlue900 = Color(0xf78bb9fd) + val colorAlphaCyan100 = Color(0xff001447) + val colorAlphaCyan1000 = Color(0xd67beffe) + val colorAlphaCyan1100 = Color(0xe0a4f4fe) + val colorAlphaCyan1200 = Color(0xe8bef5fe) + val colorAlphaCyan1300 = Color(0xf5e1fbfe) + val colorAlphaCyan1400 = Color(0xfaf1fdfe) + val colorAlphaCyan200 = Color(0xff001b4d) + val colorAlphaCyan300 = Color(0xff00265c) + val colorAlphaCyan400 = Color(0xff002d61) + val colorAlphaCyan500 = Color(0xff003f75) + val colorAlphaCyan600 = Color(0xff00538a) + val colorAlphaCyan700 = Color(0xff006da3) + val colorAlphaCyan800 = Color(0xff008ebd) + val colorAlphaCyan900 = Color(0xcf52edfe) + val colorAlphaFuchsia100 = Color(0xff2d0042) + val colorAlphaFuchsia1000 = Color(0xe6fabefe) + val colorAlphaFuchsia1100 = Color(0xedfacefd) + val colorAlphaFuchsia1200 = Color(0xf2fcd7fe) + val colorAlphaFuchsia1300 = Color(0xfafdecfe) + val colorAlphaFuchsia1400 = Color(0xfcfdf2fd) + val colorAlphaFuchsia200 = Color(0xff36004d) + val colorAlphaFuchsia300 = Color(0xff45005c) + val colorAlphaFuchsia400 = Color(0xd95a0075) + val colorAlphaFuchsia500 = Color(0x70d21fff) + val colorAlphaFuchsia600 = Color(0x8ad82ffe) + val colorAlphaFuchsia700 = Color(0xade640fc) + val colorAlphaFuchsia800 = Color(0xc7f467fe) + val colorAlphaFuchsia900 = Color(0xe0f9b3ff) + val colorAlphaGray100 = Color(0x0ad9c3df) + val colorAlphaGray1000 = Color(0xc2f0f7ff) + val colorAlphaGray1100 = Color(0xd1f0f7ff) + val colorAlphaGray1200 = Color(0xe0f1f6fd) + val colorAlphaGray1300 = Color(0xf2f6f9fe) + val colorAlphaGray1400 = Color(0xf7fbfdfe) + val colorAlphaGray200 = Color(0x0fe9dbf0) + val colorAlphaGray300 = Color(0x1aede7f4) + val colorAlphaGray400 = Color(0x21e1e4ef) + val colorAlphaGray500 = Color(0x33eceff8) + val colorAlphaGray600 = Color(0x45e7f1fd) + val colorAlphaGray700 = Color(0x63dfebfb) + val colorAlphaGray800 = Color(0x82dceafe) + val colorAlphaGray900 = Color(0xb8ecf4fe) + val colorAlphaGreen100 = Color(0xff001f0e) + val colorAlphaGreen1000 = Color(0xcf75ffc8) + val colorAlphaGreen1100 = Color(0xdba4fed7) + val colorAlphaGreen1200 = Color(0xe6bffde1) + val colorAlphaGreen1300 = Color(0xf5e2fdf1) + val colorAlphaGreen1400 = Color(0xfaedfdf5) + val colorAlphaGreen200 = Color(0xff002412) + val colorAlphaGreen300 = Color(0xff002e1b) + val colorAlphaGreen400 = Color(0xff003824) + val colorAlphaGreen500 = Color(0xff004732) + val colorAlphaGreen600 = Color(0xff005c45) + val colorAlphaGreen700 = Color(0xff00755e) + val colorAlphaGreen800 = Color(0x8a12fdc2) + val colorAlphaGreen900 = Color(0xc740fcba) + val colorAlphaLime100 = Color(0xff001f00) + val colorAlphaLime1000 = Color(0xd47bfe3e) + val colorAlphaLime1100 = Color(0xe0a4fd81) + val colorAlphaLime1200 = Color(0xe8c1fea9) + val colorAlphaLime1300 = Color(0xf7e1fdd8) + val colorAlphaLime1400 = Color(0xfaedfee7) + val colorAlphaLime200 = Color(0xff002900) + val colorAlphaLime300 = Color(0xff002e00) + val colorAlphaLime400 = Color(0xff003800) + val colorAlphaLime500 = Color(0xff004d00) + val colorAlphaLime600 = Color(0xff005c00) + val colorAlphaLime700 = Color(0x6b23ff0a) + val colorAlphaLime800 = Color(0x8c4dfe25) + val colorAlphaLime900 = Color(0xc774fe34) + val colorAlphaOrange100 = Color(0xff3d0000) + val colorAlphaOrange1000 = Color(0xfaffb175) + val colorAlphaOrange1100 = Color(0xfffdc196) + val colorAlphaOrange1200 = Color(0xfffed1b3) + val colorAlphaOrange1300 = Color(0xffffeadb) + val colorAlphaOrange1400 = Color(0xfffff2eb) + val colorAlphaOrange200 = Color(0xff470000) + val colorAlphaOrange300 = Color(0xff570000) + val colorAlphaOrange400 = Color(0xff660000) + val colorAlphaOrange500 = Color(0xff850400) + val colorAlphaOrange600 = Color(0xbdc72800) + val colorAlphaOrange700 = Color(0xb3fa5300) + val colorAlphaOrange800 = Color(0xcffe7206) + val colorAlphaOrange900 = Color(0xfafda058) + val colorAlphaPink100 = Color(0xff3d0012) + val colorAlphaPink1000 = Color(0xffffa3b9) + val colorAlphaPink1100 = Color(0xffffbdcb) + val colorAlphaPink1200 = Color(0xffffccd7) + val colorAlphaPink1300 = Color(0xffffebef) + val colorAlphaPink1400 = Color(0xfffff0f3) + val colorAlphaPink200 = Color(0xff470019) + val colorAlphaPink300 = Color(0xff570024) + val colorAlphaPink400 = Color(0xff61002d) + val colorAlphaPink500 = Color(0x75fb0473) + val colorAlphaPink600 = Color(0x94fd1277) + val colorAlphaPink700 = Color(0xc2fe1b79) + val colorAlphaPink800 = Color(0xf2fd2b78) + val colorAlphaPink900 = Color(0xffff94ad) + val colorAlphaPurple100 = Color(0xff1d005c) + val colorAlphaPurple1000 = Color(0xffc2b8ff) + val colorAlphaPurple1100 = Color(0xffcec7ff) + val colorAlphaPurple1200 = Color(0xffdbd6ff) + val colorAlphaPurple1300 = Color(0xffeeebff) + val colorAlphaPurple1400 = Color(0xfff6f5ff) + val colorAlphaPurple200 = Color(0xff22006b) + val colorAlphaPurple300 = Color(0xff2d0080) + val colorAlphaPurple400 = Color(0xff34008f) + val colorAlphaPurple500 = Color(0xab690dfd) + val colorAlphaPurple600 = Color(0xc2712bfd) + val colorAlphaPurple700 = Color(0xe67f49fd) + val colorAlphaPurple800 = Color(0xf7906bff) + val colorAlphaPurple900 = Color(0xffb7a8ff) + val colorAlphaRed100 = Color(0xff3d0000) + val colorAlphaRed1000 = Color(0xffffa89e) + val colorAlphaRed1100 = Color(0xffffbfb8) + val colorAlphaRed1200 = Color(0xffffcec7) + val colorAlphaRed1300 = Color(0xffffe8e5) + val colorAlphaRed1400 = Color(0xfffff3f0) + val colorAlphaRed200 = Color(0xff470000) + val colorAlphaRed300 = Color(0xff5c0000) + val colorAlphaRed400 = Color(0xff660000) + val colorAlphaRed500 = Color(0xff850009) + val colorAlphaRed600 = Color(0x99fe0b24) + val colorAlphaRed700 = Color(0xc4ff242f) + val colorAlphaRed800 = Color(0xf5ff2e31) + val colorAlphaRed900 = Color(0xffff988f) + val colorAlphaYellow100 = Color(0xff380300) + val colorAlphaYellow1000 = Color(0xebfec406) + val colorAlphaYellow1100 = Color(0xf7fecf16) + val colorAlphaYellow1200 = Color(0xfffed634) + val colorAlphaYellow1300 = Color(0xffffedb3) + val colorAlphaYellow1400 = Color(0xfffff4d1) + val colorAlphaYellow200 = Color(0xff420900) + val colorAlphaYellow300 = Color(0xff4d1400) + val colorAlphaYellow400 = Color(0xff571e00) + val colorAlphaYellow500 = Color(0xde753300) + val colorAlphaYellow600 = Color(0xeb854200) + val colorAlphaYellow700 = Color(0xff995700) + val colorAlphaYellow800 = Color(0xffb37100) + val colorAlphaYellow900 = Color(0xffe6ac00) + val colorBlue100 = Color(0xff00095d) + val colorBlue1000 = Color(0xff9ac0f8) + val colorBlue1100 = Color(0xffb2cffa) + val colorBlue1200 = Color(0xffc5dbfc) + val colorBlue1300 = Color(0xffe4eefe) + val colorBlue1400 = Color(0xffeff5fe) + val colorBlue200 = Color(0xff001264) + val colorBlue300 = Color(0xff001e6f) + val colorBlue400 = Color(0xff032677) + val colorBlue500 = Color(0xff083891) + val colorBlue600 = Color(0xff0b49ab) + val colorBlue700 = Color(0xff0e61d1) + val colorBlue800 = Color(0xff337fe9) + val colorBlue900 = Color(0xff89b5f6) + val colorCyan100 = Color(0xff001448) + val colorCyan1000 = Color(0xff6bccd9) + val colorCyan1100 = Color(0xff93d9e2) + val colorCyan1200 = Color(0xffafe2e9) + val colorCyan1300 = Color(0xffdbf2f5) + val colorCyan1400 = Color(0xffeaf7f9) + val colorCyan200 = Color(0xff001b4e) + val colorCyan300 = Color(0xff002559) + val colorCyan400 = Color(0xff002d61) + val colorCyan500 = Color(0xff003f75) + val colorCyan600 = Color(0xff005188) + val colorCyan700 = Color(0xff006ca4) + val colorCyan800 = Color(0xff008aba) + val colorCyan900 = Color(0xff46c3d2) + val colorFuchsia100 = Color(0xff2e0044) + val colorFuchsia1000 = Color(0xffe3abe7) + val colorFuchsia1100 = Color(0xffeac0ed) + val colorFuchsia1200 = Color(0xfff0cff2) + val colorFuchsia1300 = Color(0xfff8e9f9) + val colorFuchsia1400 = Color(0xfffbf1fb) + val colorFuchsia200 = Color(0xff37004e) + val colorFuchsia300 = Color(0xff46005e) + val colorFuchsia400 = Color(0xff4f0368) + val colorFuchsia500 = Color(0xff65177d) + val colorFuchsia600 = Color(0xff7d2394) + val colorFuchsia700 = Color(0xffa233b3) + val colorFuchsia800 = Color(0xffc153cb) + val colorFuchsia900 = Color(0xffdd9de3) + val colorGray100 = Color(0xff181a1f) + val colorGray1000 = Color(0xffb8bfc7) + val colorGray1100 = Color(0xffc8ced5) + val colorGray1200 = Color(0xffd5dae1) + val colorGray1300 = Color(0xffebeef2) + val colorGray1400 = Color(0xfff2f5f7) + val colorGray200 = Color(0xff1d1f24) + val colorGray300 = Color(0xff26282d) + val colorGray400 = Color(0xff2b2e33) + val colorGray500 = Color(0xff3c3f44) + val colorGray600 = Color(0xff4a4f55) + val colorGray700 = Color(0xff606770) + val colorGray800 = Color(0xff79818d) + val colorGray900 = Color(0xffacb4bd) + val colorGreen100 = Color(0xff001f0e) + val colorGreen1000 = Color(0xff61d2a6) + val colorGreen1100 = Color(0xff8fddbc) + val colorGreen1200 = Color(0xfface6cc) + val colorGreen1300 = Color(0xffd9f4e7) + val colorGreen1400 = Color(0xffe9f8f1) + val colorGreen200 = Color(0xff002513) + val colorGreen300 = Color(0xff002e1b) + val colorGreen400 = Color(0xff003622) + val colorGreen500 = Color(0xff004832) + val colorGreen600 = Color(0xff005a43) + val colorGreen700 = Color(0xff00745c) + val colorGreen800 = Color(0xff109173) + val colorGreen900 = Color(0xff37c998) + val colorLime100 = Color(0xff002000) + val colorLime1000 = Color(0xff6ad639) + val colorLime1100 = Color(0xff92e175) + val colorLime1200 = Color(0xffafe99a) + val colorLime1300 = Color(0xffdaf6d0) + val colorLime1400 = Color(0xffe9f9e3) + val colorLime200 = Color(0xff002600) + val colorLime300 = Color(0xff003000) + val colorLime400 = Color(0xff003700) + val colorLime500 = Color(0xff004a00) + val colorLime600 = Color(0xff005c00) + val colorLime700 = Color(0xff187611) + val colorLime800 = Color(0xff31941d) + val colorLime900 = Color(0xff5eca2f) + val colorOrange100 = Color(0xff3c0000) + val colorOrange1000 = Color(0xfffaad73) + val colorOrange1100 = Color(0xfffdc197) + val colorOrange1200 = Color(0xfffed0b1) + val colorOrange1300 = Color(0xffffeadb) + val colorOrange1400 = Color(0xfffff2ea) + val colorOrange200 = Color(0xff470000) + val colorOrange300 = Color(0xff580000) + val colorOrange400 = Color(0xff650000) + val colorOrange500 = Color(0xff830500) + val colorOrange600 = Color(0xff972206) + val colorOrange700 = Color(0xffb44007) + val colorOrange800 = Color(0xffd15f0b) + val colorOrange900 = Color(0xfff89d58) + val colorPink100 = Color(0xff3c0012) + val colorPink1000 = Color(0xffffa4b9) + val colorPink1100 = Color(0xffffbbca) + val colorPink1200 = Color(0xffffccd7) + val colorPink1300 = Color(0xffffe8ed) + val colorPink1400 = Color(0xfffff1f4) + val colorPink200 = Color(0xff450018) + val colorPink300 = Color(0xff550024) + val colorPink400 = Color(0xff61002d) + val colorPink500 = Color(0xff7c0c41) + val colorPink600 = Color(0xff99114f) + val colorPink700 = Color(0xffc51761) + val colorPink800 = Color(0xfff12c75) + val colorPink900 = Color(0xffff92ac) + val colorPurple100 = Color(0xff1c005a) + val colorPurple1000 = Color(0xffc0b5ff) + val colorPurple1100 = Color(0xffcec7ff) + val colorPurple1200 = Color(0xffdad5ff) + val colorPurple1300 = Color(0xffeeebff) + val colorPurple1400 = Color(0xfff5f3ff) + val colorPurple200 = Color(0xff22006a) + val colorPurple300 = Color(0xff2c0080) + val colorPurple400 = Color(0xff350090) + val colorPurple500 = Color(0xff4a0db1) + val colorPurple600 = Color(0xff5a27c6) + val colorPurple700 = Color(0xff7343e6) + val colorPurple800 = Color(0xff8b66f8) + val colorPurple900 = Color(0xffb6a7ff) + val colorRed100 = Color(0xff3e0000) + val colorRed1000 = Color(0xffffa79d) + val colorRed1100 = Color(0xffffbdb5) + val colorRed1200 = Color(0xffffcfc8) + val colorRed1300 = Color(0xffffe9e6) + val colorRed1400 = Color(0xfffff2ef) + val colorRed200 = Color(0xff470000) + val colorRed300 = Color(0xff590000) + val colorRed400 = Color(0xff640000) + val colorRed500 = Color(0xff830009) + val colorRed600 = Color(0xff9f0d1e) + val colorRed700 = Color(0xffc81e28) + val colorRed800 = Color(0xfff52f33) + val colorRed900 = Color(0xffff968c) + val colorThemeBg = Color(0xff101317) + val colorTransparent = Color(0x00000000) + val colorYellow100 = Color(0xff3a0300) + val colorYellow1000 = Color(0xffebb607) + val colorYellow1100 = Color(0xfff7c816) + val colorYellow1200 = Color(0xfffed632) + val colorYellow1300 = Color(0xffffedb1) + val colorYellow1400 = Color(0xfffff4d0) + val colorYellow200 = Color(0xff410900) + val colorYellow300 = Color(0xff4c1400) + val colorYellow400 = Color(0xff541d00) + val colorYellow500 = Color(0xff682e03) + val colorYellow600 = Color(0xff7c3e02) + val colorYellow700 = Color(0xff985600) + val colorYellow800 = Color(0xffb47200) + val colorYellow900 = Color(0xffe3aa00) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightColorTokens.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightColorTokens.kt new file mode 100644 index 0000000000..119db9dade --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightColorTokens.kt @@ -0,0 +1,335 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated.internal + +import androidx.compose.ui.graphics.Color +import io.element.android.compound.annotations.CoreColorToken + +@CoreColorToken +object LightColorTokens { + val colorAlphaBlue100 = Color(0x08389cff) + val colorAlphaBlue1000 = Color(0xfc0256c5) + val colorAlphaBlue1100 = Color(0xfa0148b2) + val colorAlphaBlue1200 = Color(0xfc013693) + val colorAlphaBlue1300 = Color(0xff012579) + val colorAlphaBlue1400 = Color(0xff000e66) + val colorAlphaBlue200 = Color(0x0d2474ff) + val colorAlphaBlue300 = Color(0x170a70ff) + val colorAlphaBlue400 = Color(0x290b6af9) + val colorAlphaBlue500 = Color(0x47096cf6) + val colorAlphaBlue600 = Color(0x5e0663ef) + val colorAlphaBlue700 = Color(0x820264ed) + val colorAlphaBlue800 = Color(0xbf0062eb) + val colorAlphaBlue900 = Color(0xfc0165df) + val colorAlphaCyan100 = Color(0x0816bbbb) + val colorAlphaCyan1000 = Color(0xff00649e) + val colorAlphaCyan1100 = Color(0xff00568f) + val colorAlphaCyan1200 = Color(0xff003f75) + val colorAlphaCyan1300 = Color(0xff002c61) + val colorAlphaCyan1400 = Color(0xff001a52) + val colorAlphaCyan200 = Color(0x0f16abbb) + val colorAlphaCyan300 = Color(0x1c00a8c2) + val colorAlphaCyan400 = Color(0x3800aabd) + val colorAlphaCyan500 = Color(0x6605abbd) + val colorAlphaCyan600 = Color(0x8a01aac1) + val colorAlphaCyan700 = Color(0xeb01b7cb) + val colorAlphaCyan800 = Color(0xff0095c2) + val colorAlphaCyan900 = Color(0xff0074ad) + val colorAlphaFuchsia100 = Color(0x05cc05cc) + val colorAlphaFuchsia1000 = Color(0xd6820198) + val colorAlphaFuchsia1100 = Color(0xe073038c) + val colorAlphaFuchsia1200 = Color(0xed5d0279) + val colorAlphaFuchsia1300 = Color(0xff4d0066) + val colorAlphaFuchsia1400 = Color(0xff34004d) + val colorAlphaFuchsia200 = Color(0x0ab505cc) + val colorAlphaFuchsia300 = Color(0x12b60cc6) + val colorAlphaFuchsia400 = Color(0x21bd09c3) + val colorAlphaFuchsia500 = Color(0x3bb407c0) + val colorAlphaFuchsia600 = Color(0x4fb207bb) + val colorAlphaFuchsia700 = Color(0x6eaa04b9) + val colorAlphaFuchsia800 = Color(0xa3ab03ba) + val colorAlphaFuchsia900 = Color(0xcc9900ad) + val colorAlphaGray100 = Color(0x0536699b) + val colorAlphaGray1000 = Color(0xa8030c1b) + val colorAlphaGray1100 = Color(0xb5030b16) + val colorAlphaGray1200 = Color(0xc402070d) + val colorAlphaGray1300 = Color(0xd603050c) + val colorAlphaGray1400 = Color(0xe6020408) + val colorAlphaGray200 = Color(0x0a366881) + val colorAlphaGray300 = Color(0x0f052657) + val colorAlphaGray400 = Color(0x1f052e61) + val colorAlphaGray500 = Color(0x33052448) + val colorAlphaGray600 = Color(0x42011d3c) + val colorAlphaGray700 = Color(0x59011532) + val colorAlphaGray800 = Color(0x8003152b) + val colorAlphaGray900 = Color(0x9c031021) + val colorAlphaGreen100 = Color(0x0816bb79) + val colorAlphaGreen1000 = Color(0xff006b52) + val colorAlphaGreen1100 = Color(0xff005c45) + val colorAlphaGreen1200 = Color(0xff004732) + val colorAlphaGreen1300 = Color(0xff00331f) + val colorAlphaGreen1400 = Color(0xff002411) + val colorAlphaGreen200 = Color(0x0f16bb69) + val colorAlphaGreen300 = Color(0x1c00b85c) + val colorAlphaGreen400 = Color(0x3b07b661) + val colorAlphaGreen500 = Color(0x6904b96a) + val colorAlphaGreen600 = Color(0x8f01b76e) + val colorAlphaGreen700 = Color(0xf501c18a) + val colorAlphaGreen800 = Color(0xff009975) + val colorAlphaGreen900 = Color(0xff007a62) + val colorAlphaLime100 = Color(0x0a4fcd1d) + val colorAlphaLime1000 = Color(0xff007000) + val colorAlphaLime1100 = Color(0xff006100) + val colorAlphaLime1200 = Color(0xff004d00) + val colorAlphaLime1300 = Color(0xff003800) + val colorAlphaLime1400 = Color(0xff002400) + val colorAlphaLime200 = Color(0x1238d40c) + val colorAlphaLime300 = Color(0x262ecf02) + val colorAlphaLime400 = Color(0x473ace09) + val colorAlphaLime500 = Color(0x8237ca02) + val colorAlphaLime600 = Color(0xb540ce03) + val colorAlphaLime700 = Color(0xdb39bd00) + val colorAlphaLime800 = Color(0xe8209301) + val colorAlphaLime900 = Color(0xf5107902) + val colorAlphaOrange100 = Color(0x0aff8138) + val colorAlphaOrange1000 = Color(0xffad3400) + val colorAlphaOrange1100 = Color(0xff992100) + val colorAlphaOrange1200 = Color(0xff850000) + val colorAlphaOrange1300 = Color(0xff610000) + val colorAlphaOrange1400 = Color(0xff470000) + val colorAlphaOrange200 = Color(0x12ff7d1a) + val colorAlphaOrange300 = Color(0x1cff6c0a) + val colorAlphaOrange400 = Color(0x38ff6d05) + val colorAlphaOrange500 = Color(0x5eff6a00) + val colorAlphaOrange600 = Color(0x85fc6f03) + val colorAlphaOrange700 = Color(0xbff56e00) + val colorAlphaOrange800 = Color(0xffdb6600) + val colorAlphaOrange900 = Color(0xffbd4500) + val colorAlphaPink100 = Color(0x05ff0537) + val colorAlphaPink1000 = Color(0xf7b60256) + val colorAlphaPink1100 = Color(0xf79e004c) + val colorAlphaPink1200 = Color(0xfa79013d) + val colorAlphaPink1300 = Color(0xff61002c) + val colorAlphaPink1400 = Color(0xff420017) + val colorAlphaPink200 = Color(0x0aff0537) + val colorAlphaPink300 = Color(0x14ff1447) + val colorAlphaPink400 = Color(0x21ff0037) + val colorAlphaPink500 = Color(0x3dff0037) + val colorAlphaPink600 = Color(0x54ff053f) + val colorAlphaPink700 = Color(0x78ff0040) + val colorAlphaPink800 = Color(0xbff50052) + val colorAlphaPink900 = Color(0xf5cf025e) + val colorAlphaPurple100 = Color(0x053838ff) + val colorAlphaPurple1000 = Color(0xc94502d4) + val colorAlphaPurple1100 = Color(0xdb4303c4) + val colorAlphaPurple1200 = Color(0xfc4a02b6) + val colorAlphaPurple1300 = Color(0xff34008f) + val colorAlphaPurple1400 = Color(0xff200066) + val colorAlphaPurple200 = Color(0x0a5338ff) + val colorAlphaPurple300 = Color(0x12381aff) + val colorAlphaPurple400 = Color(0x1f2f0fff) + val colorAlphaPurple500 = Color(0x332605ff) + val colorAlphaPurple600 = Color(0x452b05ff) + val colorAlphaPurple700 = Color(0x613305ff) + val colorAlphaPurple800 = Color(0x8f3b01f9) + val colorAlphaPurple900 = Color(0xba4902ed) + val colorAlphaRed100 = Color(0x08ff5938) + val colorAlphaRed1000 = Color(0xf2bb0217) + val colorAlphaRed1100 = Color(0xfca2011c) + val colorAlphaRed1200 = Color(0xff850007) + val colorAlphaRed1300 = Color(0xff610000) + val colorAlphaRed1400 = Color(0xff470000) + val colorAlphaRed200 = Color(0x0aff391f) + val colorAlphaRed300 = Color(0x14ff3814) + val colorAlphaRed400 = Color(0x26ff2b0a) + val colorAlphaRed500 = Color(0x45ff2605) + val colorAlphaRed600 = Color(0x5cff2205) + val colorAlphaRed700 = Color(0x80ff1a05) + val colorAlphaRed800 = Color(0xc4ff0505) + val colorAlphaRed900 = Color(0xe8cf0213) + val colorAlphaYellow100 = Color(0x0fffcd05) + val colorAlphaYellow1000 = Color(0xff8f4c00) + val colorAlphaYellow1100 = Color(0xff804000) + val colorAlphaYellow1200 = Color(0xff6b2e00) + val colorAlphaYellow1300 = Color(0xff571b00) + val colorAlphaYellow1400 = Color(0xff420700) + val colorAlphaYellow200 = Color(0x21ffc70f) + val colorAlphaYellow300 = Color(0x40ffc905) + val colorAlphaYellow400 = Color(0x7dffc905) + val colorAlphaYellow500 = Color(0xfffacc00) + val colorAlphaYellow600 = Color(0xfff0bc00) + val colorAlphaYellow700 = Color(0xffe0a500) + val colorAlphaYellow800 = Color(0xffbd7b00) + val colorAlphaYellow900 = Color(0xff9e5a00) + val colorBlue100 = Color(0xfff9fcff) + val colorBlue1000 = Color(0xff0558c7) + val colorBlue1100 = Color(0xff064ab1) + val colorBlue1200 = Color(0xff043894) + val colorBlue1300 = Color(0xff012478) + val colorBlue1400 = Color(0xff000e65) + val colorBlue200 = Color(0xfff4f8ff) + val colorBlue300 = Color(0xffe9f2ff) + val colorBlue400 = Color(0xffd8e7fe) + val colorBlue500 = Color(0xffbad5fc) + val colorBlue600 = Color(0xffa3c6fa) + val colorBlue700 = Color(0xff7eaff6) + val colorBlue800 = Color(0xff4088ee) + val colorBlue900 = Color(0xff0467dd) + val colorCyan100 = Color(0xfff8fdfd) + val colorCyan1000 = Color(0xff00629c) + val colorCyan1100 = Color(0xff00548c) + val colorCyan1200 = Color(0xff004077) + val colorCyan1300 = Color(0xff002b61) + val colorCyan1400 = Color(0xff00194f) + val colorCyan200 = Color(0xfff1fafb) + val colorCyan300 = Color(0xffe3f5f8) + val colorCyan400 = Color(0xffc7ecf0) + val colorCyan500 = Color(0xff9bdde5) + val colorCyan600 = Color(0xff76d1dd) + val colorCyan700 = Color(0xff15becf) + val colorCyan800 = Color(0xff0094c0) + val colorCyan900 = Color(0xff0072ac) + val colorFuchsia100 = Color(0xfffefafe) + val colorFuchsia1000 = Color(0xff972aaa) + val colorFuchsia1100 = Color(0xff822198) + val colorFuchsia1200 = Color(0xff671481) + val colorFuchsia1300 = Color(0xff4e0068) + val colorFuchsia1400 = Color(0xff34004c) + val colorFuchsia200 = Color(0xfffcf5fd) + val colorFuchsia300 = Color(0xfffaeefb) + val colorFuchsia400 = Color(0xfff6dff7) + val colorFuchsia500 = Color(0xffedc6f0) + val colorFuchsia600 = Color(0xffe7b2ea) + val colorFuchsia700 = Color(0xffdb93e1) + val colorFuchsia800 = Color(0xffc85ed1) + val colorFuchsia900 = Color(0xffad33bd) + val colorGray100 = Color(0xfffbfcfd) + val colorGray1000 = Color(0xff595e67) + val colorGray1100 = Color(0xff4c5158) + val colorGray1200 = Color(0xff3c4045) + val colorGray1300 = Color(0xff2b2d32) + val colorGray1400 = Color(0xff1b1d22) + val colorGray200 = Color(0xfff7f9fa) + val colorGray300 = Color(0xfff0f2f5) + val colorGray400 = Color(0xffe1e6ec) + val colorGray500 = Color(0xffcdd3da) + val colorGray600 = Color(0xffbdc4cc) + val colorGray700 = Color(0xffa6adb7) + val colorGray800 = Color(0xff818a95) + val colorGray900 = Color(0xff656d77) + val colorGreen100 = Color(0xfff8fdfb) + val colorGreen1000 = Color(0xff006b52) + val colorGreen1100 = Color(0xff005c45) + val colorGreen1200 = Color(0xff004933) + val colorGreen1300 = Color(0xff003420) + val colorGreen1400 = Color(0xff002311) + val colorGreen200 = Color(0xfff1fbf6) + val colorGreen300 = Color(0xffe3f7ed) + val colorGreen400 = Color(0xffc6eedb) + val colorGreen500 = Color(0xff98e1c1) + val colorGreen600 = Color(0xff71d7ae) + val colorGreen700 = Color(0xff0bc491) + val colorGreen800 = Color(0xff009b78) + val colorGreen900 = Color(0xff007a61) + val colorLime100 = Color(0xfff8fdf6) + val colorLime1000 = Color(0xff006e00) + val colorLime1100 = Color(0xff005f00) + val colorLime1200 = Color(0xff004b00) + val colorLime1300 = Color(0xff003600) + val colorLime1400 = Color(0xff002400) + val colorLime200 = Color(0xfff1fcee) + val colorLime300 = Color(0xffe0f8d9) + val colorLime400 = Color(0xffc8f1ba) + val colorLime500 = Color(0xff99e57e) + val colorLime600 = Color(0xff76db4c) + val colorLime700 = Color(0xff54c424) + val colorLime800 = Color(0xff359d18) + val colorLime900 = Color(0xff197d0c) + val colorOrange100 = Color(0xfffffaf7) + val colorOrange1000 = Color(0xffac3300) + val colorOrange1100 = Color(0xff9b2200) + val colorOrange1200 = Color(0xff850000) + val colorOrange1300 = Color(0xff620000) + val colorOrange1400 = Color(0xff450000) + val colorOrange200 = Color(0xfffff6ef) + val colorOrange300 = Color(0xffffefe4) + val colorOrange400 = Color(0xffffdfc8) + val colorOrange500 = Color(0xffffc8a1) + val colorOrange600 = Color(0xfffdb37c) + val colorOrange700 = Color(0xfff89440) + val colorOrange800 = Color(0xffdc6700) + val colorOrange900 = Color(0xffbc4500) + val colorPink100 = Color(0xfffffafb) + val colorPink1000 = Color(0xffb80a5b) + val colorPink1100 = Color(0xff9f0850) + val colorPink1200 = Color(0xff7e0642) + val colorPink1300 = Color(0xff5f002b) + val colorPink1400 = Color(0xff430017) + val colorPink200 = Color(0xfffff5f7) + val colorPink300 = Color(0xffffecf0) + val colorPink400 = Color(0xffffdee5) + val colorPink500 = Color(0xffffc2cf) + val colorPink600 = Color(0xffffadc0) + val colorPink700 = Color(0xffff88a6) + val colorPink800 = Color(0xfff7407d) + val colorPink900 = Color(0xffd20c65) + val colorPurple100 = Color(0xfffbfbff) + val colorPurple1000 = Color(0xff6b37de) + val colorPurple1100 = Color(0xff5d26cd) + val colorPurple1200 = Color(0xff4c05b5) + val colorPurple1300 = Color(0xff33008d) + val colorPurple1400 = Color(0xff200066) + val colorPurple200 = Color(0xfff8f7ff) + val colorPurple300 = Color(0xfff1efff) + val colorPurple400 = Color(0xffe6e2ff) + val colorPurple500 = Color(0xffd4cdff) + val colorPurple600 = Color(0xffc5bbff) + val colorPurple700 = Color(0xffb1a0ff) + val colorPurple800 = Color(0xff9271fd) + val colorPurple900 = Color(0xff7a47f1) + val colorRed100 = Color(0xfffffaf9) + val colorRed1000 = Color(0xffbc0f22) + val colorRed1100 = Color(0xffa4041d) + val colorRed1200 = Color(0xff850006) + val colorRed1300 = Color(0xff620000) + val colorRed1400 = Color(0xff450000) + val colorRed200 = Color(0xfffff7f6) + val colorRed300 = Color(0xffffefec) + val colorRed400 = Color(0xffffdfda) + val colorRed500 = Color(0xffffc5bc) + val colorRed600 = Color(0xffffafa5) + val colorRed700 = Color(0xffff8c81) + val colorRed800 = Color(0xffff3d3d) + val colorRed900 = Color(0xffd51928) + val colorThemeBg = Color(0xffffffff) + val colorTransparent = Color(0x00000000) + val colorYellow100 = Color(0xfffffcf0) + val colorYellow1000 = Color(0xff8f4d00) + val colorYellow1100 = Color(0xff803f00) + val colorYellow1200 = Color(0xff692e00) + val colorYellow1300 = Color(0xff541a00) + val colorYellow1400 = Color(0xff410600) + val colorYellow200 = Color(0xfffff8e0) + val colorYellow300 = Color(0xfffff2c1) + val colorYellow400 = Color(0xffffe484) + val colorYellow500 = Color(0xfffbce00) + val colorYellow600 = Color(0xfff1bd00) + val colorYellow700 = Color(0xffdea200) + val colorYellow800 = Color(0xffbe7a00) + val colorYellow900 = Color(0xff9f5b00) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightHcColorTokens.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightHcColorTokens.kt new file mode 100644 index 0000000000..86624bb597 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/internal/LightHcColorTokens.kt @@ -0,0 +1,335 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +/** + * !!! WARNING !!! + * + * THIS IS AN AUTOGENERATED FILE. + * DO NOT EDIT MANUALLY. + */ + + + +@file:Suppress("all") +package io.element.android.compound.tokens.generated.internal + +import androidx.compose.ui.graphics.Color +import io.element.android.compound.annotations.CoreColorToken + +@CoreColorToken +object LightHcColorTokens { + val colorAlphaBlue100 = Color(0x0d2474ff) + val colorAlphaBlue1000 = Color(0xfc023997) + val colorAlphaBlue1100 = Color(0xfc012e89) + val colorAlphaBlue1200 = Color(0xfc00257a) + val colorAlphaBlue1300 = Color(0xff00156b) + val colorAlphaBlue1400 = Color(0xff000b61) + val colorAlphaBlue200 = Color(0x170a70ff) + val colorAlphaBlue300 = Color(0x290b6af9) + val colorAlphaBlue400 = Color(0x380565f5) + val colorAlphaBlue500 = Color(0x5e0663ef) + val colorAlphaBlue600 = Color(0x820264ed) + val colorAlphaBlue700 = Color(0xb50062eb) + val colorAlphaBlue800 = Color(0xfc016ee9) + val colorAlphaBlue900 = Color(0xfc0241a7) + val colorAlphaCyan100 = Color(0x0f16abbb) + val colorAlphaCyan1000 = Color(0xff00437a) + val colorAlphaCyan1100 = Color(0xff003870) + val colorAlphaCyan1200 = Color(0xff003066) + val colorAlphaCyan1300 = Color(0xff001e52) + val colorAlphaCyan1400 = Color(0xff00174d) + val colorAlphaCyan200 = Color(0x1c00a8c2) + val colorAlphaCyan300 = Color(0x3800aabd) + val colorAlphaCyan400 = Color(0x4f03a9bf) + val colorAlphaCyan500 = Color(0x8a01aac1) + val colorAlphaCyan600 = Color(0xeb01b7cb) + val colorAlphaCyan700 = Color(0xff0098c2) + val colorAlphaCyan800 = Color(0xff007ab3) + val colorAlphaCyan900 = Color(0xff004d85) + val colorAlphaFuchsia100 = Color(0x0ab505cc) + val colorAlphaFuchsia1000 = Color(0xe85e007a) + val colorAlphaFuchsia1100 = Color(0xf253026f) + val colorAlphaFuchsia1200 = Color(0xff53026e) + val colorAlphaFuchsia1300 = Color(0xff3a0052) + val colorAlphaFuchsia1400 = Color(0xff34004d) + val colorAlphaFuchsia200 = Color(0x12b60cc6) + val colorAlphaFuchsia300 = Color(0x21bd09c3) + val colorAlphaFuchsia400 = Color(0x2eb105bd) + val colorAlphaFuchsia500 = Color(0x4fb207bb) + val colorAlphaFuchsia600 = Color(0x6eaa04b9) + val colorAlphaFuchsia700 = Color(0x99ab03ba) + val colorAlphaFuchsia800 = Color(0xc9a402b6) + val colorAlphaFuchsia900 = Color(0xe66a0387) + val colorAlphaGray100 = Color(0x0a366881) + val colorAlphaGray1000 = Color(0xc202060d) + val colorAlphaGray1100 = Color(0xcc03060c) + val colorAlphaGray1200 = Color(0xd4020509) + val colorAlphaGray1300 = Color(0xe000040a) + val colorAlphaGray1400 = Color(0xe6010309) + val colorAlphaGray200 = Color(0x0f052657) + val colorAlphaGray300 = Color(0x1f052e61) + val colorAlphaGray400 = Color(0x29052551) + val colorAlphaGray500 = Color(0x42011d3c) + val colorAlphaGray600 = Color(0x59011532) + val colorAlphaGray700 = Color(0x7a05152e) + val colorAlphaGray800 = Color(0x94020e22) + val colorAlphaGray900 = Color(0xba030711) + val colorAlphaGreen100 = Color(0x0f16bb69) + val colorAlphaGreen1000 = Color(0xff004d36) + val colorAlphaGreen1100 = Color(0xff00422c) + val colorAlphaGreen1200 = Color(0xff003824) + val colorAlphaGreen1300 = Color(0xff002916) + val colorAlphaGreen1400 = Color(0xff002410) + val colorAlphaGreen200 = Color(0x1c00b85c) + val colorAlphaGreen300 = Color(0x3b07b661) + val colorAlphaGreen400 = Color(0x5205b867) + val colorAlphaGreen500 = Color(0x8f01b76e) + val colorAlphaGreen600 = Color(0xf501c18a) + val colorAlphaGreen700 = Color(0xff00a37d) + val colorAlphaGreen800 = Color(0xff00856a) + val colorAlphaGreen900 = Color(0xff00573e) + val colorAlphaLime100 = Color(0x1238d40c) + val colorAlphaLime1000 = Color(0xff005200) + val colorAlphaLime1100 = Color(0xff004200) + val colorAlphaLime1200 = Color(0xff003800) + val colorAlphaLime1300 = Color(0xff002900) + val colorAlphaLime1400 = Color(0xff002400) + val colorAlphaLime200 = Color(0x262ecf02) + val colorAlphaLime300 = Color(0x473ace09) + val colorAlphaLime400 = Color(0x6637cc05) + val colorAlphaLime500 = Color(0xb540ce03) + val colorAlphaLime600 = Color(0xdb39bd00) + val colorAlphaLime700 = Color(0xe6249801) + val colorAlphaLime800 = Color(0xf2127e02) + val colorAlphaLime900 = Color(0xff005700) + val colorAlphaOrange100 = Color(0x12ff7d1a) + val colorAlphaOrange1000 = Color(0xff8a0900) + val colorAlphaOrange1100 = Color(0xff750000) + val colorAlphaOrange1200 = Color(0xff660000) + val colorAlphaOrange1300 = Color(0xff4d0000) + val colorAlphaOrange1400 = Color(0xff420000) + val colorAlphaOrange200 = Color(0x1cff6c0a) + val colorAlphaOrange300 = Color(0x38ff6d05) + val colorAlphaOrange400 = Color(0x4dff700a) + val colorAlphaOrange500 = Color(0x85fc6f03) + val colorAlphaOrange600 = Color(0xbff56e00) + val colorAlphaOrange700 = Color(0xffe06c00) + val colorAlphaOrange800 = Color(0xffc24e00) + val colorAlphaOrange900 = Color(0xff941600) + val colorAlphaPink100 = Color(0x0aff0537) + val colorAlphaPink1000 = Color(0xfa830242) + val colorAlphaPink1100 = Color(0xff70003a) + val colorAlphaPink1200 = Color(0xff660030) + val colorAlphaPink1300 = Color(0xff4d001d) + val colorAlphaPink1400 = Color(0xff420015) + val colorAlphaPink200 = Color(0x14ff1447) + val colorAlphaPink300 = Color(0x21ff0037) + val colorAlphaPink400 = Color(0x30ff0a3f) + val colorAlphaPink500 = Color(0x54ff053f) + val colorAlphaPink600 = Color(0x78ff0040) + val colorAlphaPink700 = Color(0xb3f70250) + val colorAlphaPink800 = Color(0xf5de0265) + val colorAlphaPink900 = Color(0xf78f0045) + val colorAlphaPurple100 = Color(0x0a5338ff) + val colorAlphaPurple1000 = Color(0xf24600b8) + val colorAlphaPurple1100 = Color(0xff4300a8) + val colorAlphaPurple1200 = Color(0xff360094) + val colorAlphaPurple1300 = Color(0xff240070) + val colorAlphaPurple1400 = Color(0xff1f0061) + val colorAlphaPurple200 = Color(0x12381aff) + val colorAlphaPurple300 = Color(0x1f2f0fff) + val colorAlphaPurple400 = Color(0x292b0aff) + val colorAlphaPurple500 = Color(0x452b05ff) + val colorAlphaPurple600 = Color(0x613305ff) + val colorAlphaPurple700 = Color(0x873c00ff) + val colorAlphaPurple800 = Color(0xb34c02f7) + val colorAlphaPurple900 = Color(0xe64503bf) + val colorAlphaRed100 = Color(0x0aff391f) + val colorAlphaRed1000 = Color(0xff8a000b) + val colorAlphaRed1100 = Color(0xff750000) + val colorAlphaRed1200 = Color(0xff660000) + val colorAlphaRed1300 = Color(0xff4d0000) + val colorAlphaRed1400 = Color(0xff420000) + val colorAlphaRed200 = Color(0x14ff3814) + val colorAlphaRed300 = Color(0x26ff2b0a) + val colorAlphaRed400 = Color(0x36ff2605) + val colorAlphaRed500 = Color(0x5cff2205) + val colorAlphaRed600 = Color(0x80ff1a05) + val colorAlphaRed700 = Color(0xb8ff0900) + val colorAlphaRed800 = Color(0xe3de0211) + val colorAlphaRed900 = Color(0xff99001a) + val colorAlphaYellow100 = Color(0x21ffc70f) + val colorAlphaYellow1000 = Color(0xff703200) + val colorAlphaYellow1100 = Color(0xff612700) + val colorAlphaYellow1200 = Color(0xff571d00) + val colorAlphaYellow1300 = Color(0xff470c00) + val colorAlphaYellow1400 = Color(0xff3d0500) + val colorAlphaYellow200 = Color(0x40ffc905) + val colorAlphaYellow300 = Color(0x7dffc905) + val colorAlphaYellow400 = Color(0xb8ffcc00) + val colorAlphaYellow500 = Color(0xfff0bc00) + val colorAlphaYellow600 = Color(0xffe0a500) + val colorAlphaYellow700 = Color(0xffc28100) + val colorAlphaYellow800 = Color(0xffa86500) + val colorAlphaYellow900 = Color(0xff753700) + val colorBlue100 = Color(0xfff4f8ff) + val colorBlue1000 = Color(0xff053b9a) + val colorBlue1100 = Color(0xff043088) + val colorBlue1200 = Color(0xff03277b) + val colorBlue1300 = Color(0xff001569) + val colorBlue1400 = Color(0xff000c63) + val colorBlue200 = Color(0xffe9f2ff) + val colorBlue300 = Color(0xffd8e7fe) + val colorBlue400 = Color(0xffc8ddfd) + val colorBlue500 = Color(0xffa3c6fa) + val colorBlue600 = Color(0xff7eaff6) + val colorBlue700 = Color(0xff4a8ef0) + val colorBlue800 = Color(0xff046ee8) + val colorBlue900 = Color(0xff0543a7) + val colorCyan100 = Color(0xfff1fafb) + val colorCyan1000 = Color(0xff00447b) + val colorCyan1100 = Color(0xff00376e) + val colorCyan1200 = Color(0xff002e64) + val colorCyan1300 = Color(0xff001e53) + val colorCyan1400 = Color(0xff00174d) + val colorCyan200 = Color(0xffe3f5f8) + val colorCyan300 = Color(0xffc7ecf0) + val colorCyan400 = Color(0xffb1e4eb) + val colorCyan500 = Color(0xff76d1dd) + val colorCyan600 = Color(0xff15becf) + val colorCyan700 = Color(0xff009ac3) + val colorCyan800 = Color(0xff007ab3) + val colorCyan900 = Color(0xff004c84) + val colorFuchsia100 = Color(0xfffcf5fd) + val colorFuchsia1000 = Color(0xff6c1785) + val colorFuchsia1100 = Color(0xff5c0f76) + val colorFuchsia1200 = Color(0xff52026c) + val colorFuchsia1300 = Color(0xff3b0053) + val colorFuchsia1400 = Color(0xff32004a) + val colorFuchsia200 = Color(0xfffaeefb) + val colorFuchsia300 = Color(0xfff6dff7) + val colorFuchsia400 = Color(0xfff1d2f3) + val colorFuchsia500 = Color(0xffe7b2ea) + val colorFuchsia600 = Color(0xffdb93e1) + val colorFuchsia700 = Color(0xffcb68d4) + val colorFuchsia800 = Color(0xffb937c6) + val colorFuchsia900 = Color(0xff781c90) + val colorGray100 = Color(0xfff7f9fa) + val colorGray1000 = Color(0xff3f4248) + val colorGray1100 = Color(0xff35383d) + val colorGray1200 = Color(0xff2d3034) + val colorGray1300 = Color(0xff1f2126) + val colorGray1400 = Color(0xff1a1c21) + val colorGray200 = Color(0xfff0f2f5) + val colorGray300 = Color(0xffe1e6ec) + val colorGray400 = Color(0xffd7dce3) + val colorGray500 = Color(0xffbdc4cc) + val colorGray600 = Color(0xffa6adb7) + val colorGray700 = Color(0xff878f9b) + val colorGray800 = Color(0xff6c737e) + val colorGray900 = Color(0xff474a51) + val colorGreen100 = Color(0xfff1fbf6) + val colorGreen1000 = Color(0xff004d36) + val colorGreen1100 = Color(0xff00402b) + val colorGreen1200 = Color(0xff003723) + val colorGreen1300 = Color(0xff002715) + val colorGreen1400 = Color(0xff00210f) + val colorGreen200 = Color(0xffe3f7ed) + val colorGreen300 = Color(0xffc6eedb) + val colorGreen400 = Color(0xffafe8ce) + val colorGreen500 = Color(0xff71d7ae) + val colorGreen600 = Color(0xff0bc491) + val colorGreen700 = Color(0xff00a27c) + val colorGreen800 = Color(0xff008268) + val colorGreen900 = Color(0xff00553d) + val colorLime100 = Color(0xfff1fcee) + val colorLime1000 = Color(0xff004f00) + val colorLime1100 = Color(0xff004200) + val colorLime1200 = Color(0xff003900) + val colorLime1300 = Color(0xff002900) + val colorLime1400 = Color(0xff002200) + val colorLime200 = Color(0xffe0f8d9) + val colorLime300 = Color(0xffc8f1ba) + val colorLime400 = Color(0xffafeb9b) + val colorLime500 = Color(0xff76db4c) + val colorLime600 = Color(0xff54c424) + val colorLime700 = Color(0xff3aa31a) + val colorLime800 = Color(0xff1f850f) + val colorLime900 = Color(0xff005700) + val colorOrange100 = Color(0xfffff6ef) + val colorOrange1000 = Color(0xff890800) + val colorOrange1100 = Color(0xff770000) + val colorOrange1200 = Color(0xff670000) + val colorOrange1300 = Color(0xff4c0000) + val colorOrange1400 = Color(0xff420000) + val colorOrange200 = Color(0xffffefe4) + val colorOrange300 = Color(0xffffdfc8) + val colorOrange400 = Color(0xffffd4b5) + val colorOrange500 = Color(0xfffdb37c) + val colorOrange600 = Color(0xfff89440) + val colorOrange700 = Color(0xffe26e00) + val colorOrange800 = Color(0xffc44d00) + val colorOrange900 = Color(0xff931700) + val colorPink100 = Color(0xfffff5f7) + val colorPink1000 = Color(0xff840745) + val colorPink1100 = Color(0xff72003a) + val colorPink1200 = Color(0xff64002f) + val colorPink1300 = Color(0xff4a001c) + val colorPink1400 = Color(0xff410015) + val colorPink200 = Color(0xffffecf0) + val colorPink300 = Color(0xffffdee5) + val colorPink400 = Color(0xffffd0da) + val colorPink500 = Color(0xffffadc0) + val colorPink600 = Color(0xffff88a6) + val colorPink700 = Color(0xfff94e84) + val colorPink800 = Color(0xffe00c6a) + val colorPink900 = Color(0xff92084b) + val colorPurple100 = Color(0xfff8f7ff) + val colorPurple1000 = Color(0xff4f0dba) + val colorPurple1100 = Color(0xff4200a6) + val colorPurple1200 = Color(0xff360094) + val colorPurple1300 = Color(0xff240070) + val colorPurple1400 = Color(0xff1f0062) + val colorPurple200 = Color(0xfff1efff) + val colorPurple300 = Color(0xffe6e2ff) + val colorPurple400 = Color(0xffddd8ff) + val colorPurple500 = Color(0xffc5bbff) + val colorPurple600 = Color(0xffb1a0ff) + val colorPurple700 = Color(0xff9778fe) + val colorPurple800 = Color(0xff824ef9) + val colorPurple900 = Color(0xff571cc4) + val colorRed100 = Color(0xfffff7f6) + val colorRed1000 = Color(0xff8b000c) + val colorRed1100 = Color(0xff770000) + val colorRed1200 = Color(0xff670000) + val colorRed1300 = Color(0xff4c0000) + val colorRed1400 = Color(0xff420000) + val colorRed200 = Color(0xffffefec) + val colorRed300 = Color(0xffffdfda) + val colorRed400 = Color(0xffffd1ca) + val colorRed500 = Color(0xffffafa5) + val colorRed600 = Color(0xffff8c81) + val colorRed700 = Color(0xffff4e49) + val colorRed800 = Color(0xffe11e2a) + val colorRed900 = Color(0xff99001a) + val colorThemeBg = Color(0xffffffff) + val colorTransparent = Color(0x00000000) + val colorYellow100 = Color(0xfffff8e0) + val colorYellow1000 = Color(0xff6e3100) + val colorYellow1100 = Color(0xff612600) + val colorYellow1200 = Color(0xff571d00) + val colorYellow1300 = Color(0xff450c00) + val colorYellow1400 = Color(0xff3f0500) + val colorYellow200 = Color(0xfffff2c1) + val colorYellow300 = Color(0xffffe484) + val colorYellow400 = Color(0xffffda49) + val colorYellow500 = Color(0xfff1bd00) + val colorYellow600 = Color(0xffdea200) + val colorYellow700 = Color(0xffc38100) + val colorYellow800 = Color(0xffa76300) + val colorYellow900 = Color(0xff773800) +} diff --git a/libraries/compound/src/main/kotlin/io/element/android/compound/utils/ColorUtils.kt b/libraries/compound/src/main/kotlin/io/element/android/compound/utils/ColorUtils.kt new file mode 100644 index 0000000000..f0c6c12fb0 --- /dev/null +++ b/libraries/compound/src/main/kotlin/io/element/android/compound/utils/ColorUtils.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2023, 2024 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.utils + +import androidx.compose.ui.graphics.Color + +/** + * Convert color to Human Readable Format. + */ +fun Color.toHrf(): String { + return "0x" + value.toString(16).take(8).uppercase() +} diff --git a/libraries/compound/src/main/res/drawable/ic_compound_admin.xml b/libraries/compound/src/main/res/drawable/ic_compound_admin.xml new file mode 100644 index 0000000000..8762195e7f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_admin.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_arrow_down.xml b/libraries/compound/src/main/res/drawable/ic_compound_arrow_down.xml new file mode 100644 index 0000000000..6d311ac7a2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_arrow_down.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_arrow_left.xml b/libraries/compound/src/main/res/drawable/ic_compound_arrow_left.xml new file mode 100644 index 0000000000..4e1949895f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_arrow_left.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_arrow_right.xml b/libraries/compound/src/main/res/drawable/ic_compound_arrow_right.xml new file mode 100644 index 0000000000..4a42e3c16f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_arrow_right.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_arrow_up.xml b/libraries/compound/src/main/res/drawable/ic_compound_arrow_up.xml new file mode 100644 index 0000000000..7ff26b539a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_arrow_up.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_arrow_up_right.xml b/libraries/compound/src/main/res/drawable/ic_compound_arrow_up_right.xml new file mode 100644 index 0000000000..ea686b6cff --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_arrow_up_right.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join.xml b/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join.xml new file mode 100644 index 0000000000..2c2f779ab6 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join_solid.xml new file mode 100644 index 0000000000..1346e2c889 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_ask_to_join_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_attachment.xml b/libraries/compound/src/main/res/drawable/ic_compound_attachment.xml new file mode 100644 index 0000000000..4ddf7f4df7 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_attachment.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_audio.xml b/libraries/compound/src/main/res/drawable/ic_compound_audio.xml new file mode 100644 index 0000000000..5fb9365470 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_audio.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_block.xml b/libraries/compound/src/main/res/drawable/ic_compound_block.xml new file mode 100644 index 0000000000..08ef51dce3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_block.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_bold.xml b/libraries/compound/src/main/res/drawable/ic_compound_bold.xml new file mode 100644 index 0000000000..2546a230cc --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_bold.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_calendar.xml b/libraries/compound/src/main/res/drawable/ic_compound_calendar.xml new file mode 100644 index 0000000000..72a9fe5868 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_calendar.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chart.xml b/libraries/compound/src/main/res/drawable/ic_compound_chart.xml new file mode 100644 index 0000000000..cc1c8fb662 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chart.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chat.xml b/libraries/compound/src/main/res/drawable/ic_compound_chat.xml new file mode 100644 index 0000000000..3a7e70841b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chat.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chat_new.xml b/libraries/compound/src/main/res/drawable/ic_compound_chat_new.xml new file mode 100644 index 0000000000..8bf9f6762f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chat_new.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chat_problem.xml b/libraries/compound/src/main/res/drawable/ic_compound_chat_problem.xml new file mode 100644 index 0000000000..380358478a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chat_problem.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chat_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_chat_solid.xml new file mode 100644 index 0000000000..d08def35fe --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chat_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_check.xml b/libraries/compound/src/main/res/drawable/ic_compound_check.xml new file mode 100644 index 0000000000..78f935c940 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_check.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_check_circle.xml b/libraries/compound/src/main/res/drawable/ic_compound_check_circle.xml new file mode 100644 index 0000000000..8d6147246b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_check_circle.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_check_circle_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_check_circle_solid.xml new file mode 100644 index 0000000000..d258a5c97a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_check_circle_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chevron_down.xml b/libraries/compound/src/main/res/drawable/ic_compound_chevron_down.xml new file mode 100644 index 0000000000..2ac456e988 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chevron_down.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chevron_left.xml b/libraries/compound/src/main/res/drawable/ic_compound_chevron_left.xml new file mode 100644 index 0000000000..50316a4e81 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chevron_left.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chevron_right.xml b/libraries/compound/src/main/res/drawable/ic_compound_chevron_right.xml new file mode 100644 index 0000000000..d19a9daa4d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chevron_right.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chevron_up.xml b/libraries/compound/src/main/res/drawable/ic_compound_chevron_up.xml new file mode 100644 index 0000000000..d84ebade9c --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chevron_up.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_chevron_up_down.xml b/libraries/compound/src/main/res/drawable/ic_compound_chevron_up_down.xml new file mode 100644 index 0000000000..213dfbef9f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_chevron_up_down.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_circle.xml b/libraries/compound/src/main/res/drawable/ic_compound_circle.xml new file mode 100644 index 0000000000..d5a292aa3c --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_circle.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_close.xml b/libraries/compound/src/main/res/drawable/ic_compound_close.xml new file mode 100644 index 0000000000..ef8a75f08a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_close.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_cloud.xml b/libraries/compound/src/main/res/drawable/ic_compound_cloud.xml new file mode 100644 index 0000000000..b96fd18250 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_cloud.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_cloud_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_cloud_solid.xml new file mode 100644 index 0000000000..09a91809f3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_cloud_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_code.xml b/libraries/compound/src/main/res/drawable/ic_compound_code.xml new file mode 100644 index 0000000000..c17c73c201 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_code.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_collapse.xml b/libraries/compound/src/main/res/drawable/ic_compound_collapse.xml new file mode 100644 index 0000000000..8cc9302197 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_collapse.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_company.xml b/libraries/compound/src/main/res/drawable/ic_compound_company.xml new file mode 100644 index 0000000000..28a9232c13 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_company.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_compose.xml b/libraries/compound/src/main/res/drawable/ic_compound_compose.xml new file mode 100644 index 0000000000..eaa9ca0ef1 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_compose.xml @@ -0,0 +1,14 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_computer.xml b/libraries/compound/src/main/res/drawable/ic_compound_computer.xml new file mode 100644 index 0000000000..97748e8ffd --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_computer.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_copy.xml b/libraries/compound/src/main/res/drawable/ic_compound_copy.xml new file mode 100644 index 0000000000..4492c5aca9 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_copy.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_dark_mode.xml b/libraries/compound/src/main/res/drawable/ic_compound_dark_mode.xml new file mode 100644 index 0000000000..bc4fa89cd4 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_dark_mode.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_delete.xml b/libraries/compound/src/main/res/drawable/ic_compound_delete.xml new file mode 100644 index 0000000000..dd2e3b50d0 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_delete.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_devices.xml b/libraries/compound/src/main/res/drawable/ic_compound_devices.xml new file mode 100644 index 0000000000..a399d675cf --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_devices.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_dial_pad.xml b/libraries/compound/src/main/res/drawable/ic_compound_dial_pad.xml new file mode 100644 index 0000000000..1967b8df77 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_dial_pad.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_document.xml b/libraries/compound/src/main/res/drawable/ic_compound_document.xml new file mode 100644 index 0000000000..830a36597a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_document.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_download.xml b/libraries/compound/src/main/res/drawable/ic_compound_download.xml new file mode 100644 index 0000000000..bf4c24ec26 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_download.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_download_ios.xml b/libraries/compound/src/main/res/drawable/ic_compound_download_ios.xml new file mode 100644 index 0000000000..16a45ee188 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_download_ios.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_drag_grid.xml b/libraries/compound/src/main/res/drawable/ic_compound_drag_grid.xml new file mode 100644 index 0000000000..96697b574d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_drag_grid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_drag_list.xml b/libraries/compound/src/main/res/drawable/ic_compound_drag_list.xml new file mode 100644 index 0000000000..57fe86c0e8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_drag_list.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_earpiece.xml b/libraries/compound/src/main/res/drawable/ic_compound_earpiece.xml new file mode 100644 index 0000000000..66b495b304 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_earpiece.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_edit.xml b/libraries/compound/src/main/res/drawable/ic_compound_edit.xml new file mode 100644 index 0000000000..de0c0b345a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_edit.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_edit_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_edit_solid.xml new file mode 100644 index 0000000000..33da283f4d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_edit_solid.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_email.xml b/libraries/compound/src/main/res/drawable/ic_compound_email.xml new file mode 100644 index 0000000000..223c9620f3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_email.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_email_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_email_solid.xml new file mode 100644 index 0000000000..f5c98f8cfa --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_email_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_end_call.xml b/libraries/compound/src/main/res/drawable/ic_compound_end_call.xml new file mode 100644 index 0000000000..f58a645c6e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_end_call.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_error.xml b/libraries/compound/src/main/res/drawable/ic_compound_error.xml new file mode 100644 index 0000000000..a4ea2f0016 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_error.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_error_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_error_solid.xml new file mode 100644 index 0000000000..97b8ece183 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_error_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_expand.xml b/libraries/compound/src/main/res/drawable/ic_compound_expand.xml new file mode 100644 index 0000000000..88aef8abc1 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_expand.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_explore.xml b/libraries/compound/src/main/res/drawable/ic_compound_explore.xml new file mode 100644 index 0000000000..9b62efa291 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_explore.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_export_archive.xml b/libraries/compound/src/main/res/drawable/ic_compound_export_archive.xml new file mode 100644 index 0000000000..f09775d0be --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_export_archive.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_extensions.xml b/libraries/compound/src/main/res/drawable/ic_compound_extensions.xml new file mode 100644 index 0000000000..1bd8ae7bce --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_extensions.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_extensions_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_extensions_solid.xml new file mode 100644 index 0000000000..7873a49ed6 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_extensions_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_favourite.xml b/libraries/compound/src/main/res/drawable/ic_compound_favourite.xml new file mode 100644 index 0000000000..f7845dc080 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_favourite.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_favourite_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_favourite_solid.xml new file mode 100644 index 0000000000..3fc393c572 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_favourite_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_file_error.xml b/libraries/compound/src/main/res/drawable/ic_compound_file_error.xml new file mode 100644 index 0000000000..13b3571ef8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_file_error.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_files.xml b/libraries/compound/src/main/res/drawable/ic_compound_files.xml new file mode 100644 index 0000000000..67a30b6bd8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_files.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_filter.xml b/libraries/compound/src/main/res/drawable/ic_compound_filter.xml new file mode 100644 index 0000000000..2f2b0e5f10 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_filter.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_forward.xml b/libraries/compound/src/main/res/drawable/ic_compound_forward.xml new file mode 100644 index 0000000000..e614fabb4e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_forward.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_grid.xml b/libraries/compound/src/main/res/drawable/ic_compound_grid.xml new file mode 100644 index 0000000000..223ed40a2f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_grid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_group.xml b/libraries/compound/src/main/res/drawable/ic_compound_group.xml new file mode 100644 index 0000000000..4781d1306b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_group.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_guest.xml b/libraries/compound/src/main/res/drawable/ic_compound_guest.xml new file mode 100644 index 0000000000..1bb2d99842 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_guest.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_headphones_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_headphones_off_solid.xml new file mode 100644 index 0000000000..af81d29c1d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_headphones_off_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_headphones_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_headphones_solid.xml new file mode 100644 index 0000000000..eac3a666d0 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_headphones_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_help.xml b/libraries/compound/src/main/res/drawable/ic_compound_help.xml new file mode 100644 index 0000000000..293120e8cd --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_help.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_help_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_help_solid.xml new file mode 100644 index 0000000000..80332718c2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_help_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_history.xml b/libraries/compound/src/main/res/drawable/ic_compound_history.xml new file mode 100644 index 0000000000..25d4c68509 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_history.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_home.xml b/libraries/compound/src/main/res/drawable/ic_compound_home.xml new file mode 100644 index 0000000000..0feb167199 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_home.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_home_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_home_solid.xml new file mode 100644 index 0000000000..10cca67a37 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_home_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_host.xml b/libraries/compound/src/main/res/drawable/ic_compound_host.xml new file mode 100644 index 0000000000..d45d1c0278 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_host.xml @@ -0,0 +1,14 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_image.xml b/libraries/compound/src/main/res/drawable/ic_compound_image.xml new file mode 100644 index 0000000000..58a3525b3a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_image.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_image_error.xml b/libraries/compound/src/main/res/drawable/ic_compound_image_error.xml new file mode 100644 index 0000000000..1c8d716166 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_image_error.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_indent_decrease.xml b/libraries/compound/src/main/res/drawable/ic_compound_indent_decrease.xml new file mode 100644 index 0000000000..5ada985743 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_indent_decrease.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_indent_increase.xml b/libraries/compound/src/main/res/drawable/ic_compound_indent_increase.xml new file mode 100644 index 0000000000..de5df3977a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_indent_increase.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_info.xml b/libraries/compound/src/main/res/drawable/ic_compound_info.xml new file mode 100644 index 0000000000..cf0318bb61 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_info.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_info_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_info_solid.xml new file mode 100644 index 0000000000..9101aacffc --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_info_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_inline_code.xml b/libraries/compound/src/main/res/drawable/ic_compound_inline_code.xml new file mode 100644 index 0000000000..9f78e1f8c2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_inline_code.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_italic.xml b/libraries/compound/src/main/res/drawable/ic_compound_italic.xml new file mode 100644 index 0000000000..e3fee1f82e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_italic.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_key.xml b/libraries/compound/src/main/res/drawable/ic_compound_key.xml new file mode 100644 index 0000000000..112c16d78f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_key.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_key_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_key_off.xml new file mode 100644 index 0000000000..b160e81c73 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_key_off.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_key_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_key_off_solid.xml new file mode 100644 index 0000000000..c1961ec390 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_key_off_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_key_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_key_solid.xml new file mode 100644 index 0000000000..29f9ad1a42 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_key_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_keyboard.xml b/libraries/compound/src/main/res/drawable/ic_compound_keyboard.xml new file mode 100644 index 0000000000..6216c1ccf8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_keyboard.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_labs.xml b/libraries/compound/src/main/res/drawable/ic_compound_labs.xml new file mode 100644 index 0000000000..d0bcae3bab --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_labs.xml @@ -0,0 +1,16 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_leave.xml b/libraries/compound/src/main/res/drawable/ic_compound_leave.xml new file mode 100644 index 0000000000..ad5897d4f2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_leave.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_link.xml b/libraries/compound/src/main/res/drawable/ic_compound_link.xml new file mode 100644 index 0000000000..3787cf3981 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_link.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_linux.xml b/libraries/compound/src/main/res/drawable/ic_compound_linux.xml new file mode 100644 index 0000000000..bb3216e729 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_linux.xml @@ -0,0 +1,17 @@ + + + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_list_bulleted.xml b/libraries/compound/src/main/res/drawable/ic_compound_list_bulleted.xml new file mode 100644 index 0000000000..f7fe7a8256 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_list_bulleted.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_list_numbered.xml b/libraries/compound/src/main/res/drawable/ic_compound_list_numbered.xml new file mode 100644 index 0000000000..d3fbeb2d2d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_list_numbered.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_list_view.xml b/libraries/compound/src/main/res/drawable/ic_compound_list_view.xml new file mode 100644 index 0000000000..ffd3359cfa --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_list_view.xml @@ -0,0 +1,16 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_location_navigator.xml b/libraries/compound/src/main/res/drawable/ic_compound_location_navigator.xml new file mode 100644 index 0000000000..bffa2d9f9d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_location_navigator.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_location_navigator_centred.xml b/libraries/compound/src/main/res/drawable/ic_compound_location_navigator_centred.xml new file mode 100644 index 0000000000..50f8ac655d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_location_navigator_centred.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_location_pin.xml b/libraries/compound/src/main/res/drawable/ic_compound_location_pin.xml new file mode 100644 index 0000000000..063076d4ae --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_location_pin.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_location_pin_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_location_pin_solid.xml new file mode 100644 index 0000000000..defb2d4e42 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_location_pin_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_lock.xml b/libraries/compound/src/main/res/drawable/ic_compound_lock.xml new file mode 100644 index 0000000000..9715295d94 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_lock.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_lock_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_lock_off.xml new file mode 100644 index 0000000000..a19bac4811 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_lock_off.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_lock_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_lock_solid.xml new file mode 100644 index 0000000000..6a5a11b4de --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_lock_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mac.xml b/libraries/compound/src/main/res/drawable/ic_compound_mac.xml new file mode 100644 index 0000000000..6f72038f43 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mac.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mark_as_read.xml b/libraries/compound/src/main/res/drawable/ic_compound_mark_as_read.xml new file mode 100644 index 0000000000..8de67ac4e8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mark_as_read.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mark_as_unread.xml b/libraries/compound/src/main/res/drawable/ic_compound_mark_as_unread.xml new file mode 100644 index 0000000000..6b3c53144a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mark_as_unread.xml @@ -0,0 +1,14 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mark_threads_as_read.xml b/libraries/compound/src/main/res/drawable/ic_compound_mark_threads_as_read.xml new file mode 100644 index 0000000000..5d6c12a557 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mark_threads_as_read.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_marker_read_receipts.xml b/libraries/compound/src/main/res/drawable/ic_compound_marker_read_receipts.xml new file mode 100644 index 0000000000..c70cfd3e51 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_marker_read_receipts.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mention.xml b/libraries/compound/src/main/res/drawable/ic_compound_mention.xml new file mode 100644 index 0000000000..274ccb3775 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mention.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_menu.xml b/libraries/compound/src/main/res/drawable/ic_compound_menu.xml new file mode 100644 index 0000000000..c3ee1a2ee1 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_menu.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mic_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_mic_off.xml new file mode 100644 index 0000000000..e28210c07d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mic_off.xml @@ -0,0 +1,14 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mic_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_mic_off_solid.xml new file mode 100644 index 0000000000..686809342a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mic_off_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mic_on.xml b/libraries/compound/src/main/res/drawable/ic_compound_mic_on.xml new file mode 100644 index 0000000000..793b9c8f83 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mic_on.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mic_on_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_mic_on_solid.xml new file mode 100644 index 0000000000..026f477e75 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mic_on_solid.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_minus.xml b/libraries/compound/src/main/res/drawable/ic_compound_minus.xml new file mode 100644 index 0000000000..064946b6dc --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_minus.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_mobile.xml b/libraries/compound/src/main/res/drawable/ic_compound_mobile.xml new file mode 100644 index 0000000000..8257628868 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_mobile.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_notifications.xml b/libraries/compound/src/main/res/drawable/ic_compound_notifications.xml new file mode 100644 index 0000000000..afd16aa8e9 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_notifications.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_notifications_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_notifications_off.xml new file mode 100644 index 0000000000..e4fca897a3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_notifications_off.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_notifications_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_notifications_off_solid.xml new file mode 100644 index 0000000000..4bc9fdd2ab --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_notifications_off_solid.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_notifications_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_notifications_solid.xml new file mode 100644 index 0000000000..358a18c83e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_notifications_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_offline.xml b/libraries/compound/src/main/res/drawable/ic_compound_offline.xml new file mode 100644 index 0000000000..322954e4b0 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_offline.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_overflow_horizontal.xml b/libraries/compound/src/main/res/drawable/ic_compound_overflow_horizontal.xml new file mode 100644 index 0000000000..c85d1e8da2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_overflow_horizontal.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_overflow_vertical.xml b/libraries/compound/src/main/res/drawable/ic_compound_overflow_vertical.xml new file mode 100644 index 0000000000..269e28613c --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_overflow_vertical.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_pause.xml b/libraries/compound/src/main/res/drawable/ic_compound_pause.xml new file mode 100644 index 0000000000..bcd8325107 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_pause.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_pause_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_pause_solid.xml new file mode 100644 index 0000000000..f25a7cbcfc --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_pause_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_pin.xml b/libraries/compound/src/main/res/drawable/ic_compound_pin.xml new file mode 100644 index 0000000000..0aa36f53e9 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_pin.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_pin_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_pin_solid.xml new file mode 100644 index 0000000000..9326b0fd75 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_pin_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_play.xml b/libraries/compound/src/main/res/drawable/ic_compound_play.xml new file mode 100644 index 0000000000..d7b8d3c5e5 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_play.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_play_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_play_solid.xml new file mode 100644 index 0000000000..fca650ccd8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_play_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_plus.xml b/libraries/compound/src/main/res/drawable/ic_compound_plus.xml new file mode 100644 index 0000000000..a20a59aac9 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_plus.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_polls.xml b/libraries/compound/src/main/res/drawable/ic_compound_polls.xml new file mode 100644 index 0000000000..8c0e2b5a45 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_polls.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_polls_end.xml b/libraries/compound/src/main/res/drawable/ic_compound_polls_end.xml new file mode 100644 index 0000000000..8cfe2be80e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_polls_end.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_pop_out.xml b/libraries/compound/src/main/res/drawable/ic_compound_pop_out.xml new file mode 100644 index 0000000000..7b5b07b969 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_pop_out.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_preferences.xml b/libraries/compound/src/main/res/drawable/ic_compound_preferences.xml new file mode 100644 index 0000000000..fbc271730d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_preferences.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_presence_outline_8_x_8.xml b/libraries/compound/src/main/res/drawable/ic_compound_presence_outline_8_x_8.xml new file mode 100644 index 0000000000..3d815c0696 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_presence_outline_8_x_8.xml @@ -0,0 +1,12 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_presence_solid_8_x_8.xml b/libraries/compound/src/main/res/drawable/ic_compound_presence_solid_8_x_8.xml new file mode 100644 index 0000000000..ab82df2441 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_presence_solid_8_x_8.xml @@ -0,0 +1,11 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_presence_strikethrough_8_x_8.xml b/libraries/compound/src/main/res/drawable/ic_compound_presence_strikethrough_8_x_8.xml new file mode 100644 index 0000000000..1ed8a1e492 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_presence_strikethrough_8_x_8.xml @@ -0,0 +1,12 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_public.xml b/libraries/compound/src/main/res/drawable/ic_compound_public.xml new file mode 100644 index 0000000000..3dfd7046ea --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_public.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_qr_code.xml b/libraries/compound/src/main/res/drawable/ic_compound_qr_code.xml new file mode 100644 index 0000000000..4befbcef95 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_qr_code.xml @@ -0,0 +1,17 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_quote.xml b/libraries/compound/src/main/res/drawable/ic_compound_quote.xml new file mode 100644 index 0000000000..728fe07e43 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_quote.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_raised_hand_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_raised_hand_solid.xml new file mode 100644 index 0000000000..d345569ead --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_raised_hand_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_reaction.xml b/libraries/compound/src/main/res/drawable/ic_compound_reaction.xml new file mode 100644 index 0000000000..f85f57d002 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_reaction.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_reaction_add.xml b/libraries/compound/src/main/res/drawable/ic_compound_reaction_add.xml new file mode 100644 index 0000000000..3fe88d4f8a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_reaction_add.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_reaction_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_reaction_solid.xml new file mode 100644 index 0000000000..826ac69830 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_reaction_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_reply.xml b/libraries/compound/src/main/res/drawable/ic_compound_reply.xml new file mode 100644 index 0000000000..45a797deda --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_reply.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_restart.xml b/libraries/compound/src/main/res/drawable/ic_compound_restart.xml new file mode 100644 index 0000000000..9360979845 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_restart.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_room.xml b/libraries/compound/src/main/res/drawable/ic_compound_room.xml new file mode 100644 index 0000000000..a0a278eab7 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_room.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_search.xml b/libraries/compound/src/main/res/drawable/ic_compound_search.xml new file mode 100644 index 0000000000..8e1ec94374 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_search.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_send.xml b/libraries/compound/src/main/res/drawable/ic_compound_send.xml new file mode 100644 index 0000000000..8c0d5e1159 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_send.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_send_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_send_solid.xml new file mode 100644 index 0000000000..3ac0bc6f62 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_send_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_settings.xml b/libraries/compound/src/main/res/drawable/ic_compound_settings.xml new file mode 100644 index 0000000000..7a79aa33ec --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_settings.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_settings_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_settings_solid.xml new file mode 100644 index 0000000000..7a75b037ba --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_settings_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_share.xml b/libraries/compound/src/main/res/drawable/ic_compound_share.xml new file mode 100644 index 0000000000..6abf169f20 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_share.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_share_android.xml b/libraries/compound/src/main/res/drawable/ic_compound_share_android.xml new file mode 100644 index 0000000000..a92b79a76a --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_share_android.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_share_ios.xml b/libraries/compound/src/main/res/drawable/ic_compound_share_ios.xml new file mode 100644 index 0000000000..e481978c28 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_share_ios.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_share_screen.xml b/libraries/compound/src/main/res/drawable/ic_compound_share_screen.xml new file mode 100644 index 0000000000..89f63b897c --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_share_screen.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_share_screen_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_share_screen_solid.xml new file mode 100644 index 0000000000..ee9a1aa837 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_share_screen_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_shield.xml b/libraries/compound/src/main/res/drawable/ic_compound_shield.xml new file mode 100644 index 0000000000..7d2ee79157 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_shield.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_sidebar.xml b/libraries/compound/src/main/res/drawable/ic_compound_sidebar.xml new file mode 100644 index 0000000000..4bd5a0b3e3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_sidebar.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_sign_out.xml b/libraries/compound/src/main/res/drawable/ic_compound_sign_out.xml new file mode 100644 index 0000000000..a6ded2b7a8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_sign_out.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_spinner.xml b/libraries/compound/src/main/res/drawable/ic_compound_spinner.xml new file mode 100644 index 0000000000..80721fdce8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_spinner.xml @@ -0,0 +1,11 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_spotlight.xml b/libraries/compound/src/main/res/drawable/ic_compound_spotlight.xml new file mode 100644 index 0000000000..acaad53b3b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_spotlight.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_spotlight_view.xml b/libraries/compound/src/main/res/drawable/ic_compound_spotlight_view.xml new file mode 100644 index 0000000000..724cdf91cf --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_spotlight_view.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_strikethrough.xml b/libraries/compound/src/main/res/drawable/ic_compound_strikethrough.xml new file mode 100644 index 0000000000..a472c6c97e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_strikethrough.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_switch_camera_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_switch_camera_solid.xml new file mode 100644 index 0000000000..a7695e40ff --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_switch_camera_solid.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_take_photo.xml b/libraries/compound/src/main/res/drawable/ic_compound_take_photo.xml new file mode 100644 index 0000000000..d6dbb4d568 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_take_photo.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_take_photo_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_take_photo_solid.xml new file mode 100644 index 0000000000..2db8a6cdf0 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_take_photo_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_text_formatting.xml b/libraries/compound/src/main/res/drawable/ic_compound_text_formatting.xml new file mode 100644 index 0000000000..4126080fa9 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_text_formatting.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_threads.xml b/libraries/compound/src/main/res/drawable/ic_compound_threads.xml new file mode 100644 index 0000000000..4fa1e877d1 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_threads.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_threads_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_threads_solid.xml new file mode 100644 index 0000000000..4db292231d --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_threads_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_time.xml b/libraries/compound/src/main/res/drawable/ic_compound_time.xml new file mode 100644 index 0000000000..b29bb29de7 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_time.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_underline.xml b/libraries/compound/src/main/res/drawable/ic_compound_underline.xml new file mode 100644 index 0000000000..c90d6bc591 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_underline.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_unknown.xml b/libraries/compound/src/main/res/drawable/ic_compound_unknown.xml new file mode 100644 index 0000000000..87afe69e02 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_unknown.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_unknown_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_unknown_solid.xml new file mode 100644 index 0000000000..89b6a89056 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_unknown_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_unpin.xml b/libraries/compound/src/main/res/drawable/ic_compound_unpin.xml new file mode 100644 index 0000000000..c7aee251f4 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_unpin.xml @@ -0,0 +1,14 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user.xml b/libraries/compound/src/main/res/drawable/ic_compound_user.xml new file mode 100644 index 0000000000..948bda3e4e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user_add.xml b/libraries/compound/src/main/res/drawable/ic_compound_user_add.xml new file mode 100644 index 0000000000..81d9aaf1bb --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user_add.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user_add_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_user_add_solid.xml new file mode 100644 index 0000000000..693db72c06 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user_add_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user_profile.xml b/libraries/compound/src/main/res/drawable/ic_compound_user_profile.xml new file mode 100644 index 0000000000..222b9510ea --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user_profile.xml @@ -0,0 +1,15 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user_profile_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_user_profile_solid.xml new file mode 100644 index 0000000000..5d268642e0 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user_profile_solid.xml @@ -0,0 +1,12 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_user_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_user_solid.xml new file mode 100644 index 0000000000..c281d6f009 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_user_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_verified.xml b/libraries/compound/src/main/res/drawable/ic_compound_verified.xml new file mode 100644 index 0000000000..f30bec93ff --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_verified.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call.xml new file mode 100644 index 0000000000..4f1c9b1ba7 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call_declined_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call_declined_solid.xml new file mode 100644 index 0000000000..a6b699c6bd --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call_declined_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call_missed_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call_missed_solid.xml new file mode 100644 index 0000000000..57c1502560 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call_missed_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call_off.xml new file mode 100644 index 0000000000..6466ec2848 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call_off.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call_off_solid.xml new file mode 100644 index 0000000000..35a5796577 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call_off_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_video_call_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_video_call_solid.xml new file mode 100644 index 0000000000..ec4cf0902e --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_video_call_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_visibility_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_visibility_off.xml new file mode 100644 index 0000000000..c4234584a3 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_visibility_off.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_visibility_on.xml b/libraries/compound/src/main/res/drawable/ic_compound_visibility_on.xml new file mode 100644 index 0000000000..a66dcfa429 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_visibility_on.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_voice_call.xml b/libraries/compound/src/main/res/drawable/ic_compound_voice_call.xml new file mode 100644 index 0000000000..579738d57b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_voice_call.xml @@ -0,0 +1,13 @@ + + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_voice_call_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_voice_call_solid.xml new file mode 100644 index 0000000000..428e2fa3d1 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_voice_call_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_volume_off.xml b/libraries/compound/src/main/res/drawable/ic_compound_volume_off.xml new file mode 100644 index 0000000000..e240c01b0b --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_volume_off.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_volume_off_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_volume_off_solid.xml new file mode 100644 index 0000000000..6c801e7a16 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_volume_off_solid.xml @@ -0,0 +1,10 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_volume_on.xml b/libraries/compound/src/main/res/drawable/ic_compound_volume_on.xml new file mode 100644 index 0000000000..453a2578e2 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_volume_on.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_volume_on_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_volume_on_solid.xml new file mode 100644 index 0000000000..232571342f --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_volume_on_solid.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_warning.xml b/libraries/compound/src/main/res/drawable/ic_compound_warning.xml new file mode 100644 index 0000000000..53b838ca56 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_warning.xml @@ -0,0 +1,13 @@ + + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_web_browser.xml b/libraries/compound/src/main/res/drawable/ic_compound_web_browser.xml new file mode 100644 index 0000000000..baaf15c059 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_web_browser.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_windows.xml b/libraries/compound/src/main/res/drawable/ic_compound_windows.xml new file mode 100644 index 0000000000..37a3915dc8 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_windows.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_workspace.xml b/libraries/compound/src/main/res/drawable/ic_compound_workspace.xml new file mode 100644 index 0000000000..3871fde4b4 --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_workspace.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/main/res/drawable/ic_compound_workspace_solid.xml b/libraries/compound/src/main/res/drawable/ic_compound_workspace_solid.xml new file mode 100644 index 0000000000..51c5c9f9cb --- /dev/null +++ b/libraries/compound/src/main/res/drawable/ic_compound_workspace_solid.xml @@ -0,0 +1,9 @@ + + + diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/AvatarColorsTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/AvatarColorsTest.kt new file mode 100644 index 0000000000..015cd5341c --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/AvatarColorsTest.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.AvatarColorsPreviewDark +import io.element.android.compound.theme.AvatarColorsPreviewLight +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class AvatarColorsTest { + @Test + @Config(sdk = [35], qualifiers = "xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("Avatar Colors - Light.png")) { + AvatarColorsPreviewLight() + } + captureRoboImage(file = screenshotFile("Avatar Colors - Dark.png")) { + AvatarColorsPreviewDark() + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundIconTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundIconTest.kt new file mode 100644 index 0000000000..9ae73a6205 --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundIconTest.kt @@ -0,0 +1,66 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.material3.Icon +import androidx.compose.runtime.Composable +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.previews.IconsCompoundPreviewDark +import io.element.android.compound.previews.IconsCompoundPreviewLight +import io.element.android.compound.previews.IconsCompoundPreviewRtl +import io.element.android.compound.previews.IconsPreview +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.tokens.generated.CompoundIcons +import kotlinx.collections.immutable.toImmutableList +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class CompoundIconTest { + @Test + @Config(sdk = [35], qualifiers = "w1024dp-h2048dp") + fun screenshots() { + captureRoboImage(file = screenshotFile("Compound Icons - Light.png")) { + IconsCompoundPreviewLight() + } + captureRoboImage(file = screenshotFile("Compound Icons - Rtl.png")) { + IconsCompoundPreviewRtl() + } + captureRoboImage(file = screenshotFile("Compound Icons - Dark.png")) { + IconsCompoundPreviewDark() + } + captureRoboImage(file = screenshotFile("Compound Vector Icons - Light.png")) { + val content: List<@Composable ColumnScope.() -> Unit> = CompoundIcons.all.map { + @Composable { Icon(imageVector = it, contentDescription = null) } + } + ElementTheme { + IconsPreview( + title = "Compound Vector Icons", + content = content.toImmutableList() + ) + } + } + captureRoboImage(file = screenshotFile("Compound Vector Icons - Dark.png")) { + val content: List<@Composable ColumnScope.() -> Unit> = CompoundIcons.all.map { + @Composable { Icon(imageVector = it, contentDescription = null) } + } + ElementTheme(darkTheme = true) { + IconsPreview( + title = "Compound Vector Icons", + content = content.toImmutableList() + ) + } + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundTypographyTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundTypographyTest.kt new file mode 100644 index 0000000000..2d50e6287d --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/CompoundTypographyTest.kt @@ -0,0 +1,65 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.tokens.generated.TypographyTokens +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class CompoundTypographyTest { + @Test + @Config(sdk = [35], qualifiers = "h2048dp-xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("Compound Typography.png")) { + ElementTheme { + Surface { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + with(TypographyTokens) { + TypographyTokenPreview(fontHeadingXlBold, "Heading XL Bold") + TypographyTokenPreview(fontHeadingXlRegular, "Heading XL Regular") + TypographyTokenPreview(fontHeadingLgBold, "Heading LG Bold") + TypographyTokenPreview(fontHeadingLgRegular, "Heading LG Regular") + TypographyTokenPreview(fontHeadingMdBold, "Heading MD Bold") + TypographyTokenPreview(fontHeadingMdRegular, "Heading MD Regular") + TypographyTokenPreview(fontHeadingSmMedium, "Heading SM Medium") + TypographyTokenPreview(fontHeadingSmRegular, "Heading SM Regular") + TypographyTokenPreview(fontBodyLgMedium, "Body LG Medium") + TypographyTokenPreview(fontBodyLgRegular, "Body LG Regular") + TypographyTokenPreview(fontBodyMdMedium, "Body MD Medium") + TypographyTokenPreview(fontBodyMdRegular, "Body MD Regular") + TypographyTokenPreview(fontBodySmMedium, "Body SM Medium") + TypographyTokenPreview(fontBodySmRegular, "Body SM Regular") + TypographyTokenPreview(fontBodyXsMedium, "Body XS Medium") + TypographyTokenPreview(fontBodyXsRegular, "Body XS Regular") + } + } + } + } + } + } + + @Composable + private fun TypographyTokenPreview(style: TextStyle, text: String) { + Text(text = text, style = style) + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/ForcedDarkElementThemeTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/ForcedDarkElementThemeTest.kt new file mode 100644 index 0000000000..341b7cb650 --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/ForcedDarkElementThemeTest.kt @@ -0,0 +1,57 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.theme.ForcedDarkElementTheme +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class ForcedDarkElementThemeTest { + @Test + @Config(sdk = [35], qualifiers = "xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("ForcedDarkElementTheme.png")) { + ElementTheme { + Surface { + Column( + modifier = Modifier.padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text(text = "Outside") + ForcedDarkElementTheme { + Surface { + Box(modifier = Modifier.fillMaxSize()) { + Text(text = "Inside ForcedDarkElementTheme", modifier = Modifier.align(Alignment.Center)) + } + } + } + } + } + } + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/LegacyColorsTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/LegacyColorsTest.kt new file mode 100644 index 0000000000..ecfbbe81cd --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/LegacyColorsTest.kt @@ -0,0 +1,72 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.previews.ColorPreview +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ElementTheme +import io.element.android.compound.theme.LinkColor +import io.element.android.compound.theme.SnackBarLabelColorDark +import io.element.android.compound.theme.SnackBarLabelColorLight +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class LegacyColorsTest { + @Test + @Config(sdk = [35], qualifiers = "xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("Legacy Colors.png")) { + ElementTheme { + Surface { + Column(modifier = Modifier.padding(16.dp)) { + Text(text = "Legacy Colors") + Spacer(modifier = Modifier.height(10.dp)) + LegacyColorPreview( + color = LinkColor, + name = "Link" + ) + LegacyColorPreview( + color = SnackBarLabelColorLight, + name = "SnackBar Label - Light" + ) + LegacyColorPreview( + color = SnackBarLabelColorDark, + name = "SnackBar Label - Dark" + ) + } + } + } + } + } + + @Composable + private fun LegacyColorPreview(color: Color, name: String) { + ColorPreview( + backgroundColor = Color.White, + foregroundColor = Color.Black, + name = name, + color = color + ) + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialColorSchemeTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialColorSchemeTest.kt new file mode 100644 index 0000000000..7542eaa4fc --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialColorSchemeTest.kt @@ -0,0 +1,96 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ColorsSchemeDarkHcPreview +import io.element.android.compound.theme.ColorsSchemeDarkPreview +import io.element.android.compound.theme.ColorsSchemeLightHcPreview +import io.element.android.compound.theme.ColorsSchemeLightPreview +import io.element.android.compound.theme.ElementTheme +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class MaterialColorSchemeTest { + @Test + @Config(sdk = [35], qualifiers = "h2048dp-xhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("Material3 Colors - Light.png")) { + ElementTheme { + Surface { + Column(modifier = Modifier.padding(16.dp)) { + Text( + text = "M3 Light colors", + style = TextStyle.Default.copy(fontSize = 18.sp), + ) + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemeLightPreview() + } + } + } + } + captureRoboImage(file = screenshotFile("Material3 Colors - Light HC.png")) { + ElementTheme { + Surface { + Column(modifier = Modifier.padding(16.dp)) { + Text( + text = "M3 Light HC colors", + style = TextStyle.Default.copy(fontSize = 18.sp), + ) + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemeLightHcPreview() + } + } + } + } + captureRoboImage(file = screenshotFile("Material3 Colors - Dark.png")) { + ElementTheme { + Surface { + Column(modifier = Modifier.padding(16.dp)) { + Text( + text = "M3 Dark colors", + style = TextStyle.Default.copy(fontSize = 18.sp), + ) + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemeDarkPreview() + } + } + } + } + captureRoboImage(file = screenshotFile("Material3 Colors - Dark HC.png")) { + ElementTheme { + Surface { + Column(modifier = Modifier.padding(16.dp)) { + Text( + text = "M3 Dark HC colors", + style = TextStyle.Default.copy(fontSize = 18.sp), + ) + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemeDarkHcPreview() + } + } + } + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTextTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTextTest.kt new file mode 100644 index 0000000000..764d4de77c --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTextTest.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.MaterialTextPreview +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class MaterialTextTest { + @Test + @Config(sdk = [35], qualifiers = "w480dp-h1200dp-xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("MaterialText Colors.png")) { + MaterialTextPreview() + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTypographyTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTypographyTest.kt new file mode 100644 index 0000000000..4f77a070ed --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialTypographyTest.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.previews.TypographyPreview +import io.element.android.compound.screenshot.utils.screenshotFile +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class MaterialTypographyTest { + @Test + @Config(sdk = [35], qualifiers = "h2048dp-xxhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("Material Typography.png")) { + TypographyPreview() + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialYouThemeTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialYouThemeTest.kt new file mode 100644 index 0000000000..694d2c9fc6 --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/MaterialYouThemeTest.kt @@ -0,0 +1,68 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.previews.ColorsSchemePreview +import io.element.android.compound.screenshot.utils.screenshotFile +import io.element.android.compound.theme.ElementTheme +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class MaterialYouThemeTest { + @Test + @Config(sdk = [35], qualifiers = "h2048dp-xhdpi") + fun screenshots() { + captureRoboImage(file = screenshotFile("MaterialYou Theme - Light.png")) { + ElementTheme(dynamicColor = true) { + Surface { + Column( + modifier = Modifier.padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text(text = "Material You Theme - Light") + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemePreview(Color.White, Color.Black, ElementTheme.materialColors) + } + } + } + } + captureRoboImage(file = screenshotFile("MaterialYou Theme - Dark.png")) { + ElementTheme(dynamicColor = true, darkTheme = true) { + Surface { + Column( + modifier = Modifier.padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Text(text = "Material You Theme - Dark") + Spacer(modifier = Modifier.height(12.dp)) + ColorsSchemePreview(Color.White, Color.Black, ElementTheme.materialColors) + } + } + } + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/SemanticColorsTest.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/SemanticColorsTest.kt new file mode 100644 index 0000000000..7e5fabd96a --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/SemanticColorsTest.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.github.takahirom.roborazzi.captureRoboImage +import io.element.android.compound.previews.CompoundSemanticColorsDark +import io.element.android.compound.previews.CompoundSemanticColorsDarkHc +import io.element.android.compound.previews.CompoundSemanticColorsLight +import io.element.android.compound.previews.CompoundSemanticColorsLightHc +import io.element.android.compound.screenshot.utils.screenshotFile +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(AndroidJUnit4::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class SemanticColorsTest { + @Config(sdk = [35], qualifiers = "h2000dp-xhdpi") + @Test + fun screenshots() { + captureRoboImage(file = screenshotFile("Compound Semantic Colors - Light.png")) { + CompoundSemanticColorsLight() + } + + captureRoboImage(file = screenshotFile("Compound Semantic Colors - Light HC.png")) { + CompoundSemanticColorsLightHc() + } + + captureRoboImage(file = screenshotFile("Compound Semantic Colors - Dark.png")) { + CompoundSemanticColorsDark() + } + + captureRoboImage(file = screenshotFile("Compound Semantic Colors - Dark HC.png")) { + CompoundSemanticColorsDarkHc() + } + } +} diff --git a/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/utils/ScreenshotUtils.kt b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/utils/ScreenshotUtils.kt new file mode 100644 index 0000000000..3d4c9b3824 --- /dev/null +++ b/libraries/compound/src/test/kotlin/io/element/android/compound/screenshot/utils/ScreenshotUtils.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2023, 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.compound.screenshot.utils + +import java.io.File + +/** + * Returns a [File] object for a screenshot with the given [filename]. + * This is to ensure we have a consistent location for all screenshots. + */ +fun screenshotFile(filename: String): File { + return File("screenshots", filename) +} diff --git a/libraries/designsystem/build.gradle.kts b/libraries/designsystem/build.gradle.kts index c2eec20b8c..3983317055 100644 --- a/libraries/designsystem/build.gradle.kts +++ b/libraries/designsystem/build.gradle.kts @@ -27,7 +27,7 @@ android { } dependencies { - api(libs.compound) + api(projects.libraries.compound) implementation(libs.androidx.compose.material3.windowsizeclass) implementation(libs.androidx.compose.material3.adaptive) diff --git a/tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistComposableTest.kt b/tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistComposableTest.kt index d1435e409d..181c63350b 100644 --- a/tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistComposableTest.kt +++ b/tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistComposableTest.kt @@ -36,6 +36,15 @@ class KonsistComposableTest { "OutlinedButton", "SimpleAlertDialogContent", "TextButton", + "AvatarColorsPreviewLight", + "AvatarColorsPreviewDark", + "IconsCompoundPreviewLight", + "IconsCompoundPreviewRtl", + "IconsCompoundPreviewDark", + "CompoundSemanticColorsLight", + "CompoundSemanticColorsLightHc", + "CompoundSemanticColorsDark", + "CompoundSemanticColorsDarkHc", ) .assertTrue( additionalMessage = diff --git a/tools/compound/addAutoMirrored.py b/tools/compound/addAutoMirrored.py new file mode 100644 index 0000000000..a8e22c42a5 --- /dev/null +++ b/tools/compound/addAutoMirrored.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 + +files = [ + "ic_compound_arrow_left.xml", + "ic_compound_arrow_right.xml", + "ic_compound_arrow_up_right.xml", + "ic_compound_attachment.xml", + "ic_compound_block.xml", + "ic_compound_chart.xml", + "ic_compound_chat.xml", + "ic_compound_chat_new.xml", + "ic_compound_chat_problem.xml", + "ic_compound_chat_solid.xml", + "ic_compound_chevron_left.xml", + "ic_compound_chevron_right.xml", + "ic_compound_cloud.xml", + "ic_compound_cloud_solid.xml", + "ic_compound_collapse.xml", + "ic_compound_company.xml", + "ic_compound_compose.xml", + "ic_compound_copy.xml", + "ic_compound_dark_mode.xml", + "ic_compound_devices.xml", + "ic_compound_document.xml", + "ic_compound_earpiece.xml", + "ic_compound_edit.xml", + "ic_compound_edit_solid.xml", + "ic_compound_expand.xml", + "ic_compound_extensions.xml", + "ic_compound_extensions_solid.xml", + "ic_compound_file_error.xml", + "ic_compound_files.xml", + "ic_compound_forward.xml", + "ic_compound_guest.xml", + "ic_compound_history.xml", + "ic_compound_host.xml", + "ic_compound_image.xml", + "ic_compound_image_error.xml", + "ic_compound_indent_decrease.xml", + "ic_compound_indent_increase.xml", + "ic_compound_italic.xml", + "ic_compound_key.xml", + "ic_compound_key_off.xml", + "ic_compound_key_off_solid.xml", + "ic_compound_key_solid.xml", + "ic_compound_leave.xml", + "ic_compound_link.xml", + "ic_compound_list_bulleted.xml", + "ic_compound_lock_off.xml", + "ic_compound_mark_as_unread.xml", + "ic_compound_mark_threads_as_read.xml", + "ic_compound_marker_read_receipts.xml", + "ic_compound_mic_off.xml", + "ic_compound_mic_off_solid.xml", + "ic_compound_notifications_off.xml", + "ic_compound_notifications_off_solid.xml", + "ic_compound_offline.xml", + "ic_compound_play.xml", + "ic_compound_play_solid.xml", + "ic_compound_polls.xml", + "ic_compound_polls_end.xml", + "ic_compound_pop_out.xml", + "ic_compound_qr_code.xml", + "ic_compound_quote.xml", + "ic_compound_reaction_add.xml", + "ic_compound_reply.xml", + "ic_compound_restart.xml", + "ic_compound_room.xml", + "ic_compound_search.xml", + "ic_compound_send.xml", + "ic_compound_send_solid.xml", + "ic_compound_share_android.xml", + "ic_compound_sidebar.xml", + "ic_compound_sign_out.xml", + "ic_compound_spinner.xml", + "ic_compound_spotlight.xml", + "ic_compound_switch_camera_solid.xml", + "ic_compound_threads.xml", + "ic_compound_threads_solid.xml", + "ic_compound_unknown.xml", + "ic_compound_unknown_solid.xml", + "ic_compound_unpin.xml", + "ic_compound_user_add.xml", + "ic_compound_user_add_solid.xml", + "ic_compound_video_call.xml", + "ic_compound_video_call_declined_solid.xml", + "ic_compound_video_call_missed_solid.xml", + "ic_compound_video_call_off.xml", + "ic_compound_video_call_off_solid.xml", + "ic_compound_video_call_solid.xml", + "ic_compound_visibility_off.xml", + "ic_compound_voice_call.xml", + "ic_compound_voice_call_solid.xml", + "ic_compound_volume_off.xml", + "ic_compound_volume_off_solid.xml", + "ic_compound_volume_on.xml", + "ic_compound_volume_on_solid.xml", +] + + +def main(): + for file in files: + # Open file for read + with open("./libraries/compound/src/main/res/drawable/" + file, 'r') as f: + data = f.read().split("\n") + # Open file to write + with open("./libraries/compound/src/main/res/drawable/" + file, 'w') as f: + # Write new data + # write the 3 first lines in data + for i in range(3): + f.write(data[i] + "\n") + f.write(" android:autoMirrored=\"true\"\n") + # write the rest of the data + for i in range(3, len(data) - 1): + f.write(data[i] + "\n") + print("Added autoMirrored to " + str(len(files)) + " files.") + + +if __name__ == "__main__": + main() diff --git a/tools/compound/import_tokens.sh b/tools/compound/import_tokens.sh new file mode 100755 index 0000000000..700decf81e --- /dev/null +++ b/tools/compound/import_tokens.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +set -e + +BRANCH='main' + +while getopts b: flag +do + case "${flag}" in + b) BRANCH=${OPTARG};; + *) echo "usage: $0 [-b branch]" >&2 + exit 1 ;; + esac +done + +echo "Branch used: $BRANCH" + +echo "Cloning the compound-design-tokens repository..." +if [ -d tmpCompound ]; then + echo "Deleting tmpCompound folder..." + rm -rf tmpCompound +fi +mkdir tmpCompound +pushd tmpCompound +git clone --branch "${BRANCH}" https://github.com/vector-im/compound-design-tokens + +echo "Copying files from tokens repository..." +rm -R ../libraries/compound/src/main/res/drawable +cp -R compound-design-tokens/assets/android/res/drawable ../libraries/compound/src/main/res/ +cp -R compound-design-tokens/assets/android/src/* ../libraries/compound/src/main/kotlin/io/element/android/compound/tokens/generated/ +popd + +echo "Adding autoMirrored attribute..." +python3 ./tools/compound/addAutoMirrored.py + +echo "Removing temporary files..." +rm -rf tmpCompound + +echo "Done!"