From ec37f40b66cd62c24f64d4ee989c0e63a2ac97de Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 15:33:16 +0200 Subject: [PATCH 1/7] fix(plugin): don't merge sibling modules sharing POM name and description MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `DuplicateMode.MERGE` grouped libraries by `groupId + name + description`, which collapsed distinct sibling modules of the same project onto a single entry — one of them silently disappeared from the output. `com.materialkolor:material-kolor` and `com.materialkolor:material-color-utilities` both publish `MaterialKolor` with the same description, so only one of the two was reported (independent of `mergePlatformArtifacts`). Sub-cluster each duplicate group by module id, so only actual platform variants of the same module are merged (`collection` + `collection-jvm`), never sibling modules. The surviving entry now breaks name-length ties on the shortest uniqueId, making the root module the deterministic survivor of a KMP merge. Fixes #1430 --- .../aboutlibraries/plugin/util/LibraryUtil.kt | 43 ++++++++++++-- .../plugin/KmpAndroidFunctionalTest.kt | 5 +- .../MergePlatformArtifactsFunctionalTest.kt | 6 +- .../plugin/util/LibraryUtilTest.kt | 56 +++++++++++++++++++ 4 files changed, 100 insertions(+), 10 deletions(-) create mode 100644 plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt index 5de0084b8..06fc04d79 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt @@ -10,23 +10,27 @@ fun List.processDuplicates( duplicateMode: DuplicateMode, duplicateRule: DuplicateRule, ): List { - fun mappedLibs(): Map> { + fun mappedLibs(): List> { return this.groupBy { when (duplicateRule) { DuplicateRule.GROUP -> it.groupId + it.licenses.joinToString(",") DuplicateRule.SIMPLE -> it.groupId + it.name DuplicateRule.EXACT -> it.groupId + it.name + it.description?.toMD5() } - } + }.values.flatMap { it.clusterByArtifactId() } } when (duplicateMode) { DuplicateMode.MERGE -> { val deDuplicatedList = mutableListOf() - mappedLibs().forEach { (_, group) -> + mappedLibs().forEach { group -> val kept = if (group.size > 1) { - // on duplicates, assumption is the shorter title is the base dependency - group.minByOrNull { it.name?.length ?: it.description?.length ?: Int.MAX_VALUE } ?: group.first() + // on duplicates, assumption is the shorter title is the base dependency; on a + // tie (a KMP publication names every platform artifact identically) the + // shortest id is the root module the others are platform variants of + group.minWithOrNull( + compareBy({ it.name?.length ?: it.description?.length ?: Int.MAX_VALUE }, { it.uniqueId.length }) + ) ?: group.first() } else { group.first() } @@ -41,7 +45,7 @@ fun List.processDuplicates( } DuplicateMode.LINK -> { - mappedLibs().forEach { (_, group) -> + mappedLibs().forEach { group -> if (group.size > 1) { val allAssociated = group.map { it.uniqueId } group.forEach { @@ -59,6 +63,33 @@ fun List.processDuplicates( } } +/** + * Splits libraries the [DuplicateRule] considered equal into clusters that really are one library + * published under several coordinates: a Kotlin Multiplatform publication such as + * `androidx.collection:collection` + `collection-jvm`, where the platform artifact id is the root + * id plus a target suffix. + * + * Sibling modules of one project routinely share the POM `name` and `description` — e.g. + * `com.materialkolor:material-kolor` and `com.materialkolor:material-color-utilities`, both named + * "MaterialKolor" with the same description. Those are distinct libraries, and merging them + * silently dropped one of them. + */ +private fun List.clusterByArtifactId(): List> { + if (size < 2) return listOf(this) + // `Library.artifactId` is the full `group:artifact:version` — the module name is what a + // platform suffix is appended to + fun Library.module() = uniqueId.substringAfterLast(':') + + // shortest first, so the root module is the one every platform artifact attaches to + val clusters = mutableListOf>>() // root module -> members + for (library in sortedBy { it.module().length }) { + val module = library.module() + val cluster = clusters.firstOrNull { (root, _) -> module.startsWith("$root-") } + if (cluster != null) cluster.second += library else clusters += module to mutableListOf(library) + } + return clusters.map { it.second } +} + fun Library.merge(with: Library) { val orgLib = this with.name?.takeIf { it.isNotBlank() }?.also { orgLib.name = it } diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/KmpAndroidFunctionalTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/KmpAndroidFunctionalTest.kt index 034a6e066..cc6463624 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/KmpAndroidFunctionalTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/KmpAndroidFunctionalTest.kt @@ -111,8 +111,9 @@ class KmpAndroidFunctionalTest { val content = File(projectDir, "build/generated/aboutLibraries/aboutlibraries.json").readText() val gson = extractLibraryEntry(content, "com.google.code.gson:gson") ?: error("gson entry not found in output: $content") - // resolves through the KMP `available-at` redirect, so it lands under its platform artifact - val annotation = extractLibraryEntry(content, "androidx.annotation:annotation-jvm") + // resolves through the KMP `available-at` redirect; the redirect shell and the platform + // artifact are merged onto the root module they share + val annotation = extractLibraryEntry(content, "androidx.annotation:annotation") ?: error("androidx.annotation entry not found in output: $content") // no raw configuration name may leak into the field diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt index 6fac7ffc2..dacad840b 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt @@ -97,10 +97,12 @@ class MergePlatformArtifactsFunctionalTest { ?: error("expected the declared root coordinate to be reported") assertEquals(setOf("js", "jvm"), targetsOf(merged) - "metadata", "Entry: $merged") + // without merging the platform artifacts are still collapsed by `DuplicateMode.MERGE`, but + // only into the root module they are variants of — their own ids are gone either way val unmerged = runKmpExport(mergePlatformArtifacts = false) assertFalse( - unmerged.contains("\"uniqueId\":\"androidx.collection:collection\","), - "without merging the survivor is a platform artifact, not the root. Output:\n$unmerged" + unmerged.contains("\"uniqueId\":\"androidx.collection:collection-js\","), + "platform artifacts must not survive the duplicate merge. Output:\n$unmerged" ) } diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt new file mode 100644 index 000000000..230cb7291 --- /dev/null +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt @@ -0,0 +1,56 @@ +package com.mikepenz.aboutlibraries.plugin.util + +import com.mikepenz.aboutlibraries.plugin.DuplicateMode +import com.mikepenz.aboutlibraries.plugin.DuplicateRule +import com.mikepenz.aboutlibraries.plugin.mapping.Library +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test + +class LibraryUtilTest { + + private fun library(uniqueId: String, name: String, description: String = "Material You dynamic color") = Library( + uniqueId = uniqueId, + artifactVersion = "5.0.0", + name = name, + description = description, + website = null, + developers = emptyList(), + organization = null, + scm = null, + ) + + /** + * https://github.com/mikepenz/AboutLibraries/issues/1430 — sibling modules of one project share + * the POM `name` and `description`, which made every duplicate rule consider them equal. Only + * the platform artifacts of the *same* module may be merged. + */ + @Test + fun `sibling modules sharing name and description are not merged`() { + val libraries = listOf( + library("com.materialkolor:material-kolor", "MaterialKolor"), + library("com.materialkolor:material-kolor-jvm", "MaterialKolor"), + library("com.materialkolor:material-color-utilities", "MaterialKolor"), + library("com.materialkolor:material-color-utilities-jvm", "MaterialKolor"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals( + setOf("com.materialkolor:material-kolor", "com.materialkolor:material-color-utilities"), + result.map { it.uniqueId }.toSet(), + ) + } + + @Test + fun `platform artifacts of the same module are still merged`() { + val libraries = listOf( + library("androidx.collection:collection-jvm", "collection"), + library("androidx.collection:collection", "collection"), + library("androidx.collection:collection-js", "collection"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) + } +} From d65ecf0fb93db39de89df3eebad7f9f935b05fc0 Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 15:51:53 +0200 Subject: [PATCH 2/7] fix(plugin): `DuplicateMode.LINK` associated itself instead of its siblings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `associated` is documented as "references all associated libraries", but the filter kept only the entry equal to the library's own `uniqueId` — every linked library ended up with a single-element list pointing at itself. The field is serialized into `aboutlibraries.json`, so the wrong value shipped. Also adds unit coverage for the duplicate handling that had none: `LINK`, `KEEP`, and the `SIMPLE` / `GROUP` rules. --- .../aboutlibraries/plugin/util/LibraryUtil.kt | 3 +- .../plugin/util/LibraryUtilTest.kt | 109 +++++++++++++++++- 2 files changed, 110 insertions(+), 2 deletions(-) diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt index 06fc04d79..2bc924398 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt @@ -49,7 +49,8 @@ fun List.processDuplicates( if (group.size > 1) { val allAssociated = group.map { it.uniqueId } group.forEach { - it.associated = allAssociated.filter { a -> a == it.uniqueId } + // the *other* members of the group — a library is not associated to itself + it.associated = allAssociated.filter { a -> a != it.uniqueId } } } } diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt index 230cb7291..f0b305859 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt @@ -8,7 +8,12 @@ import org.junit.jupiter.api.Test class LibraryUtilTest { - private fun library(uniqueId: String, name: String, description: String = "Material You dynamic color") = Library( + private fun library( + uniqueId: String, + name: String, + description: String = "Material You dynamic color", + licenses: Set = setOf("Apache-2.0"), + ) = Library( uniqueId = uniqueId, artifactVersion = "5.0.0", name = name, @@ -17,6 +22,7 @@ class LibraryUtilTest { developers = emptyList(), organization = null, scm = null, + licenses = licenses, ) /** @@ -53,4 +59,105 @@ class LibraryUtilTest { assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) } + + @Test + fun `KEEP reports every coordinate untouched`() { + val libraries = listOf( + library("androidx.collection:collection", "collection"), + library("androidx.collection:collection-jvm", "collection"), + ) + + val result = libraries.processDuplicates(DuplicateMode.KEEP, DuplicateRule.EXACT) + + assertEquals(libraries.map { it.uniqueId }, result.map { it.uniqueId }) + assertEquals(listOf(null, null), result.map { it.associated }) + } + + @Test + fun `LINK keeps every coordinate and cross-references the others`() { + val libraries = listOf( + library("androidx.collection:collection", "collection"), + library("androidx.collection:collection-jvm", "collection"), + library("androidx.collection:collection-js", "collection"), + ) + + val result = libraries.processDuplicates(DuplicateMode.LINK, DuplicateRule.EXACT) + + assertEquals(libraries.map { it.uniqueId }, result.map { it.uniqueId }, "LINK must not drop anything") + // a library is associated to its siblings, never to itself + assertEquals( + listOf( + setOf("androidx.collection:collection-jvm", "androidx.collection:collection-js"), + setOf("androidx.collection:collection", "androidx.collection:collection-js"), + setOf("androidx.collection:collection", "androidx.collection:collection-jvm"), + ), + result.map { it.associated?.toSet() }, + ) + } + + @Test + fun `LINK leaves a library without siblings unassociated`() { + val libraries = listOf( + library("androidx.collection:collection", "collection"), + library("com.google.code.gson:gson", "Gson"), + ) + + val result = libraries.processDuplicates(DuplicateMode.LINK, DuplicateRule.EXACT) + + assertEquals(listOf(null, null), result.map { it.associated }) + } + + /** [DuplicateRule.SIMPLE] matches on group + name, so a differing description must not split. */ + @Test + fun `SIMPLE ignores the description EXACT distinguishes on`() { + val libraries = listOf( + library("androidx.collection:collection", "collection", description = "Standalone efficient collections."), + library("androidx.collection:collection-jvm", "collection", description = "Collections, but for the JVM."), + ) + + assertEquals( + listOf("androidx.collection:collection"), + libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.SIMPLE).map { it.uniqueId }, + ) + assertEquals( + libraries.map { it.uniqueId }, + libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT).map { it.uniqueId }, + "differing descriptions are distinct under EXACT", + ) + } + + /** [DuplicateRule.GROUP] matches on group + licenses alone, ignoring name and description. */ + @Test + fun `GROUP matches on licenses regardless of name`() { + val libraries = listOf( + library("androidx.collection:collection", "collection", description = "Collections"), + library("androidx.collection:collection-jvm", "Collection for JVM", description = "Collections for the JVM"), + library("androidx.collection:collection-ktx", "Collection KTX", licenses = setOf("MIT")), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.GROUP) + + assertEquals( + setOf("androidx.collection:collection", "androidx.collection:collection-ktx"), + result.map { it.uniqueId }.toSet(), + "the two Apache-2.0 artifacts merge, the MIT one stays on its own", + ) + } + + /** + * The coarser rules match far more libraries, so the module-id clustering that keeps sibling + * modules apart has to hold for them too — group + licenses alone would otherwise collapse a + * whole group onto one entry. + */ + @Test + fun `GROUP does not merge unrelated modules sharing a license`() { + val libraries = listOf( + library("com.materialkolor:material-kolor", "MaterialKolor"), + library("com.materialkolor:material-color-utilities", "MaterialKolor"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.GROUP) + + assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) + } } From 06f96cdae82a7f00b6768093127f6ceab6034891 Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 16:06:31 +0200 Subject: [PATCH 3/7] fix(plugin): only merge suffixes that name a Kotlin target MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Clustering by "root id plus any suffix" merged a sibling module into a shorter one it happened to share a prefix with: `androidx.core:core-ktx` collapsed into `core`, and a `com.foo:android` module absorbed `android-core` / `android-extra` whole. Require the suffix to be a Kotlin target name as published (`jvm`, `android`, `js`, `wasm-js`, `desktop`, `linuxx64`, `iossimulatorarm64`, …). An unrecognized target degrades to reporting the artifact separately — the pre-merge output — never to a wrong merge. --- .../aboutlibraries/plugin/util/LibraryUtil.kt | 25 ++++++++- .../plugin/util/LibraryUtilTest.kt | 51 +++++++++++++++++++ 2 files changed, 75 insertions(+), 1 deletion(-) diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt index 2bc924398..361d9c093 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt @@ -85,12 +85,35 @@ private fun List.clusterByArtifactId(): List> { val clusters = mutableListOf>>() // root module -> members for (library in sortedBy { it.module().length }) { val module = library.module() - val cluster = clusters.firstOrNull { (root, _) -> module.startsWith("$root-") } + val cluster = clusters.firstOrNull { (root, _) -> module.isPlatformArtifactOf(root) } if (cluster != null) cluster.second += library else clusters += module to mutableListOf(library) } return clusters.map { it.second } } +/** + * Kotlin target names as they appear in a published artifact id, lowercased: the fixed targets, the + * Compose/Kotlin publication suffixes, and the native target families (`linuxx64`, + * `iossimulatorarm64`, `watchosdevicearm64`, …). + */ +private val PLATFORM_SUFFIX = Regex( + "jvm[a-z0-9]*|android|js|wasm-?(js|wasi)|desktop|uikit|native|metadata|common|" + + "(linux|mingw|macos|ios|watchos|tvos|androidnative)[a-z0-9]*" +) + +/** + * Whether this module id looks like a platform artifact of [root] — the root id plus a Kotlin + * target suffix (`collection` → `collection-jvm`). + * + * Matching the suffix against known target names rather than accepting any suffix is what keeps a + * sibling module from being swallowed by a shorter one it happens to share a prefix with + * (`androidx.core:core` must not absorb `core-ktx`, a `com.foo:android` module must not absorb + * `android-core`). An unknown target name degrades to reporting the artifact separately, which is + * the same output as before merging — never to a wrong merge. + */ +private fun String.isPlatformArtifactOf(root: String): Boolean = + startsWith("$root-") && PLATFORM_SUFFIX.matches(substring(root.length + 1)) + fun Library.merge(with: Library) { val orgLib = this with.name?.takeIf { it.isNotBlank() }?.also { orgLib.name = it } diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt index f0b305859..f24f5af8a 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt @@ -160,4 +160,55 @@ class LibraryUtilTest { assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) } + + @Test + fun `native and web platform artifacts are merged too`() { + val libraries = listOf( + library("androidx.collection:collection", "collection"), + library("androidx.collection:collection-iossimulatorarm64", "collection"), + library("androidx.collection:collection-linuxx64", "collection"), + library("androidx.collection:collection-wasm-js", "collection"), + library("androidx.collection:collection-jvmstubs", "collection"), + library("androidx.collection:collection-desktop", "collection"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) + } + + /** + * A sibling module whose id happens to start with a shorter module's id is not a platform + * artifact of it — only a known Kotlin target suffix makes one. + */ + @Test + fun `a shorter sibling module does not absorb the ones it prefixes`() { + val libraries = listOf( + library("com.foo:android", "Foo"), + library("com.foo:android-core", "Foo"), + library("com.foo:android-core-jvm", "Foo"), + library("com.foo:android-extra", "Foo"), + library("com.foo:android-extra-jvm", "Foo"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals( + setOf("com.foo:android", "com.foo:android-core", "com.foo:android-extra"), + result.map { it.uniqueId }.toSet(), + "each module keeps its own entry, absorbing only its own platform artifact", + ) + } + + @Test + fun `a non-target suffix is not treated as a platform artifact`() { + val libraries = listOf( + library("androidx.core:core", "Core"), + library("androidx.core:core-ktx", "Core"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) + } } From 4d81486314a6b37b0abf034bca0f2a2a18c66369 Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 16:55:55 +0200 Subject: [PATCH 4/7] refactor(plugin): cluster duplicates by the `available-at` redirect, not the id MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The suffix allowlist inferred the platform-variant relationship from artifact names. Gradle already knows it exactly: `DependencyCollector.redirectTargetModule()` reads it from `ResolvedVariantResult.getExternalVariant()`, and the result rides along on `DependencyCoordinates.rootModule`. Record redirects unconditionally rather than only under `mergePlatformArtifacts`, and pass the resulting "platform artifact id -> root module id" map into `processDuplicates`. The duplicate handling runs on the default `MERGE` whether or not the flag is set, so the relationship has to be known in both modes; the flag keeps deciding only whether the root coordinate also becomes the reported `uniqueId`. Drops the target-name regex. Any suffix a publisher invents now merges correctly, and no sibling module can be absorbed by one it shares a prefix with. Costs one `Optional` lookup per resolved component (~0.5µs, measured ~0.04ms per export on a 248-component graph) — a component exposes only the variant selected in this graph, so there is no variant list to walk. Populating `rootModule` unconditionally changes the task's build-cache key once. --- .../plugin/BaseAboutLibrariesTask.kt | 2 +- .../plugin/util/DependencyCollector.kt | 17 +- .../plugin/util/LibraryPostProcessor.kt | 23 ++- .../aboutlibraries/plugin/util/LibraryUtil.kt | 57 +----- .../plugin/util/LibraryUtilTest.kt | 169 +++++++++++------- 5 files changed, 148 insertions(+), 120 deletions(-) diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/BaseAboutLibrariesTask.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/BaseAboutLibrariesTask.kt index e4c601703..1fc5b4592 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/BaseAboutLibrariesTask.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/BaseAboutLibrariesTask.kt @@ -476,7 +476,7 @@ abstract class BaseAboutLibrariesTask : DefaultTask() { // the Maven Model Builder for each occurrence — a measurable execution-time cost on // larger projects. val allCoords: Set = resolvedPerConfigCoords.values.flatten().toSet() - val parsedByCoord: Map = DependencyCollector(includePlatform.get()) + val parsedByCoord: Map = DependencyCollector(includePlatform.get(), mergePlatformArtifacts.get()) .loadDependenciesFromCoordinates(allCoords, resolvedPomFileMap) .associateBy { it.dependencyCoordinates } val variantToDependencyData = resolvedPerConfigCoords.mapValues { (_, coords) -> diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/DependencyCollector.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/DependencyCollector.kt index 555532de3..602bc3879 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/DependencyCollector.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/DependencyCollector.kt @@ -90,9 +90,15 @@ internal class DependencyCollector( val id = root.id // Non-null when this component is a pure Gradle `available-at` redirect (a KMP root module // such as `androidx.collection:collection` pointing at `androidx.collection:collection-jvm`). - // With `mergePlatformArtifacts` its module name is recorded, so the artifact it points at - // can be reported under the declared coordinate. - val redirectTarget = if (mergePlatformArtifacts) root.redirectTargetModule() else null + // Its module name is recorded so the artifact it points at can be tied back to the declared + // coordinate. + // + // Recorded unconditionally, not only under `mergePlatformArtifacts`: the duplicate handling + // needs to know which artifacts are variants of one module in every mode, and this is the + // authoritative answer. The flag decides only whether the root coordinate also becomes the + // reported `uniqueId` — see [loadLibraryFromPom]. Costs one `Optional` lookup per resolved + // component (~0.5µs), as a component exposes only the variant selected in this graph. + val redirectTarget = root.redirectTargetModule() var ignoreSuffix: String? = null when { redirectTarget != null -> { @@ -243,8 +249,9 @@ internal class DependencyCollector( // With `mergePlatformArtifacts` a KMP platform artifact is reported under the root coordinate it was // resolved through, so the id matches what was declared in the build script. Everything else - // (name, description, licenses, …) still comes from the resolved variant's POM. - val uniqueId = pom.groupId + ":" + (coordinates.rootModule ?: pom.artifactId) + // (name, description, licenses, …) still comes from the resolved variant's POM. Without the + // flag the root is only remembered (on the coordinate), never substituted. + val uniqueId = pom.groupId + ":" + (coordinates.rootModule.takeIf { mergePlatformArtifacts } ?: pom.artifactId) // check if we shall skip this specific uniqueId if (shouldSkip(uniqueId)) return null diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryPostProcessor.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryPostProcessor.kt index 02b42045b..0570fae59 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryPostProcessor.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryPostProcessor.kt @@ -258,11 +258,32 @@ internal class LibraryPostProcessor( } return ResultContainer( - librariesList.processDuplicates(duplicationMode, duplicationRule).sortedBy { it.uniqueId }, + librariesList.processDuplicates(duplicationMode, duplicationRule, rootIds()).sortedBy { it.uniqueId }, licensesMap ) } + /** + * `uniqueId` of a resolved artifact → `uniqueId` of the module it is a platform artifact of. + * + * Built from the Gradle `available-at` redirects recorded during dependency collection, so the + * duplicate handling merges exactly the artifacts of one Kotlin Multiplatform publication + * (`androidx.collection:collection-jvm` → `androidx.collection:collection`) and never two + * sibling modules that merely share their POM `name` and `description`. + * + * Empty for non-multiplatform graphs. Identity entries (a redirect shell mapping to itself) + * are harmless — they are what an unlisted artifact falls back to anyway. + */ + private fun rootIds(): Map = buildMap { + variantToDependencyData.values.forEach { dependencies -> + dependencies.forEach { dependency -> + val coordinates = dependency.dependencyCoordinates + val rootModule = coordinates.rootModule ?: return@forEach + put(dependency.uniqueId, "${coordinates.group}:$rootModule") + } + } + } + /** * Ensures and applies fixes to the library names (shorten, ...) */ diff --git a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt index 361d9c093..69645f290 100644 --- a/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt +++ b/plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtil.kt @@ -9,6 +9,7 @@ import com.mikepenz.aboutlibraries.plugin.mapping.Library fun List.processDuplicates( duplicateMode: DuplicateMode, duplicateRule: DuplicateRule, + rootIds: Map = emptyMap(), ): List { fun mappedLibs(): List> { return this.groupBy { @@ -17,7 +18,11 @@ fun List.processDuplicates( DuplicateRule.SIMPLE -> it.groupId + it.name DuplicateRule.EXACT -> it.groupId + it.name + it.description?.toMD5() } - }.values.flatMap { it.clusterByArtifactId() } + }.values.flatMap { group -> + // one cluster per module: platform artifacts fall onto the root they redirect from, + // everything else onto its own id + group.groupBy { rootIds[it.uniqueId] ?: it.uniqueId }.values + } } when (duplicateMode) { @@ -64,56 +69,6 @@ fun List.processDuplicates( } } -/** - * Splits libraries the [DuplicateRule] considered equal into clusters that really are one library - * published under several coordinates: a Kotlin Multiplatform publication such as - * `androidx.collection:collection` + `collection-jvm`, where the platform artifact id is the root - * id plus a target suffix. - * - * Sibling modules of one project routinely share the POM `name` and `description` — e.g. - * `com.materialkolor:material-kolor` and `com.materialkolor:material-color-utilities`, both named - * "MaterialKolor" with the same description. Those are distinct libraries, and merging them - * silently dropped one of them. - */ -private fun List.clusterByArtifactId(): List> { - if (size < 2) return listOf(this) - // `Library.artifactId` is the full `group:artifact:version` — the module name is what a - // platform suffix is appended to - fun Library.module() = uniqueId.substringAfterLast(':') - - // shortest first, so the root module is the one every platform artifact attaches to - val clusters = mutableListOf>>() // root module -> members - for (library in sortedBy { it.module().length }) { - val module = library.module() - val cluster = clusters.firstOrNull { (root, _) -> module.isPlatformArtifactOf(root) } - if (cluster != null) cluster.second += library else clusters += module to mutableListOf(library) - } - return clusters.map { it.second } -} - -/** - * Kotlin target names as they appear in a published artifact id, lowercased: the fixed targets, the - * Compose/Kotlin publication suffixes, and the native target families (`linuxx64`, - * `iossimulatorarm64`, `watchosdevicearm64`, …). - */ -private val PLATFORM_SUFFIX = Regex( - "jvm[a-z0-9]*|android|js|wasm-?(js|wasi)|desktop|uikit|native|metadata|common|" + - "(linux|mingw|macos|ios|watchos|tvos|androidnative)[a-z0-9]*" -) - -/** - * Whether this module id looks like a platform artifact of [root] — the root id plus a Kotlin - * target suffix (`collection` → `collection-jvm`). - * - * Matching the suffix against known target names rather than accepting any suffix is what keeps a - * sibling module from being swallowed by a shorter one it happens to share a prefix with - * (`androidx.core:core` must not absorb `core-ktx`, a `com.foo:android` module must not absorb - * `android-core`). An unknown target name degrades to reporting the artifact separately, which is - * the same output as before merging — never to a wrong merge. - */ -private fun String.isPlatformArtifactOf(root: String): Boolean = - startsWith("$root-") && PLATFORM_SUFFIX.matches(substring(root.length + 1)) - fun Library.merge(with: Library) { val orgLib = this with.name?.takeIf { it.isNotBlank() }?.also { orgLib.name = it } diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt index f24f5af8a..228c78a92 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/util/LibraryUtilTest.kt @@ -25,6 +25,14 @@ class LibraryUtilTest { licenses = licenses, ) + /** + * The `available-at` redirects the dependency collection records: platform artifact id → the + * root module id it is published under. In a real build this comes from Gradle, not from the + * artifact names. + */ + private fun redirects(root: String, vararg platformArtifacts: String): Map = + platformArtifacts.associateWith { root } + /** * https://github.com/mikepenz/AboutLibraries/issues/1430 — sibling modules of one project share * the POM `name` and `description`, which made every duplicate rule consider them equal. Only @@ -39,7 +47,12 @@ class LibraryUtilTest { library("com.materialkolor:material-color-utilities-jvm", "MaterialKolor"), ) - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + val result = libraries.processDuplicates( + DuplicateMode.MERGE, + DuplicateRule.EXACT, + redirects("com.materialkolor:material-kolor", "com.materialkolor:material-kolor-jvm") + + redirects("com.materialkolor:material-color-utilities", "com.materialkolor:material-color-utilities-jvm"), + ) assertEquals( setOf("com.materialkolor:material-kolor", "com.materialkolor:material-color-utilities"), @@ -48,18 +61,88 @@ class LibraryUtilTest { } @Test - fun `platform artifacts of the same module are still merged`() { + fun `platform artifacts of the same module are merged`() { val libraries = listOf( library("androidx.collection:collection-jvm", "collection"), library("androidx.collection:collection", "collection"), library("androidx.collection:collection-js", "collection"), ) - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + val result = libraries.processDuplicates( + DuplicateMode.MERGE, + DuplicateRule.EXACT, + redirects("androidx.collection:collection", "androidx.collection:collection-jvm", "androidx.collection:collection-js"), + ) assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) } + /** + * The published suffix is the publisher's choice — `-wasm-js` carries a second hyphen, + * `-desktop` names no Kotlin target at all. Since the relationship is read from Gradle rather + * than inferred from the id, none of that matters. + */ + @Test + fun `platform artifacts are merged whatever their suffix looks like`() { + val platformArtifacts = listOf( + "androidx.collection:collection-iossimulatorarm64", + "androidx.collection:collection-linuxx64", + "androidx.collection:collection-wasm-js", + "androidx.collection:collection-jvmstubs", + "androidx.collection:collection-desktop", + "androidx.collection:collection-some-target-invented-next-year", + ) + val libraries = (listOf("androidx.collection:collection") + platformArtifacts).map { library(it, "collection") } + + val result = libraries.processDuplicates( + DuplicateMode.MERGE, + DuplicateRule.EXACT, + redirects("androidx.collection:collection", *platformArtifacts.toTypedArray()), + ) + + assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) + } + + /** + * A sibling module whose id happens to start with a shorter module's id is not a platform + * artifact of it — only an `available-at` redirect makes one. + */ + @Test + fun `a shorter sibling module does not absorb the ones it prefixes`() { + val libraries = listOf( + library("com.foo:android", "Foo"), + library("com.foo:android-core", "Foo"), + library("com.foo:android-core-jvm", "Foo"), + library("com.foo:android-extra", "Foo"), + library("com.foo:android-extra-jvm", "Foo"), + ) + + val result = libraries.processDuplicates( + DuplicateMode.MERGE, + DuplicateRule.EXACT, + redirects("com.foo:android-core", "com.foo:android-core-jvm") + + redirects("com.foo:android-extra", "com.foo:android-extra-jvm"), + ) + + assertEquals( + setOf("com.foo:android", "com.foo:android-core", "com.foo:android-extra"), + result.map { it.uniqueId }.toSet(), + "each module keeps its own entry, absorbing only its own platform artifact", + ) + } + + @Test + fun `a module without a redirect is never merged into another`() { + val libraries = listOf( + library("androidx.core:core", "Core"), + library("androidx.core:core-ktx", "Core"), + ) + + val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) + + assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) + } + @Test fun `KEEP reports every coordinate untouched`() { val libraries = listOf( @@ -67,7 +150,11 @@ class LibraryUtilTest { library("androidx.collection:collection-jvm", "collection"), ) - val result = libraries.processDuplicates(DuplicateMode.KEEP, DuplicateRule.EXACT) + val result = libraries.processDuplicates( + DuplicateMode.KEEP, + DuplicateRule.EXACT, + redirects("androidx.collection:collection", "androidx.collection:collection-jvm"), + ) assertEquals(libraries.map { it.uniqueId }, result.map { it.uniqueId }) assertEquals(listOf(null, null), result.map { it.associated }) @@ -81,7 +168,11 @@ class LibraryUtilTest { library("androidx.collection:collection-js", "collection"), ) - val result = libraries.processDuplicates(DuplicateMode.LINK, DuplicateRule.EXACT) + val result = libraries.processDuplicates( + DuplicateMode.LINK, + DuplicateRule.EXACT, + redirects("androidx.collection:collection", "androidx.collection:collection-jvm", "androidx.collection:collection-js"), + ) assertEquals(libraries.map { it.uniqueId }, result.map { it.uniqueId }, "LINK must not drop anything") // a library is associated to its siblings, never to itself @@ -114,14 +205,15 @@ class LibraryUtilTest { library("androidx.collection:collection", "collection", description = "Standalone efficient collections."), library("androidx.collection:collection-jvm", "collection", description = "Collections, but for the JVM."), ) + val rootIds = redirects("androidx.collection:collection", "androidx.collection:collection-jvm") assertEquals( listOf("androidx.collection:collection"), - libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.SIMPLE).map { it.uniqueId }, + libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.SIMPLE, rootIds).map { it.uniqueId }, ) assertEquals( libraries.map { it.uniqueId }, - libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT).map { it.uniqueId }, + libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT, rootIds).map { it.uniqueId }, "differing descriptions are distinct under EXACT", ) } @@ -135,7 +227,11 @@ class LibraryUtilTest { library("androidx.collection:collection-ktx", "Collection KTX", licenses = setOf("MIT")), ) - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.GROUP) + val result = libraries.processDuplicates( + DuplicateMode.MERGE, + DuplicateRule.GROUP, + redirects("androidx.collection:collection", "androidx.collection:collection-jvm"), + ) assertEquals( setOf("androidx.collection:collection", "androidx.collection:collection-ktx"), @@ -145,9 +241,9 @@ class LibraryUtilTest { } /** - * The coarser rules match far more libraries, so the module-id clustering that keeps sibling - * modules apart has to hold for them too — group + licenses alone would otherwise collapse a - * whole group onto one entry. + * The coarser rules match far more libraries, so the clustering that keeps sibling modules + * apart has to hold for them too — group + licenses alone would otherwise collapse a whole + * group onto one entry. */ @Test fun `GROUP does not merge unrelated modules sharing a license`() { @@ -160,55 +256,4 @@ class LibraryUtilTest { assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) } - - @Test - fun `native and web platform artifacts are merged too`() { - val libraries = listOf( - library("androidx.collection:collection", "collection"), - library("androidx.collection:collection-iossimulatorarm64", "collection"), - library("androidx.collection:collection-linuxx64", "collection"), - library("androidx.collection:collection-wasm-js", "collection"), - library("androidx.collection:collection-jvmstubs", "collection"), - library("androidx.collection:collection-desktop", "collection"), - ) - - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) - - assertEquals(listOf("androidx.collection:collection"), result.map { it.uniqueId }) - } - - /** - * A sibling module whose id happens to start with a shorter module's id is not a platform - * artifact of it — only a known Kotlin target suffix makes one. - */ - @Test - fun `a shorter sibling module does not absorb the ones it prefixes`() { - val libraries = listOf( - library("com.foo:android", "Foo"), - library("com.foo:android-core", "Foo"), - library("com.foo:android-core-jvm", "Foo"), - library("com.foo:android-extra", "Foo"), - library("com.foo:android-extra-jvm", "Foo"), - ) - - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) - - assertEquals( - setOf("com.foo:android", "com.foo:android-core", "com.foo:android-extra"), - result.map { it.uniqueId }.toSet(), - "each module keeps its own entry, absorbing only its own platform artifact", - ) - } - - @Test - fun `a non-target suffix is not treated as a platform artifact`() { - val libraries = listOf( - library("androidx.core:core", "Core"), - library("androidx.core:core-ktx", "Core"), - ) - - val result = libraries.processDuplicates(DuplicateMode.MERGE, DuplicateRule.EXACT) - - assertEquals(libraries.map { it.uniqueId }.toSet(), result.map { it.uniqueId }.toSet()) - } } From 84b1a617392f79f890a559cec5a0b3320681ed3b Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 17:04:52 +0200 Subject: [PATCH 5/7] test(plugin): cover the reported #1430 case end to end MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The sibling-module case was only asserted at unit level, with a hand-fed redirect map. This exercises a real resolution of `com.materialkolor:material-kolor:5.0.0` with `mergePlatformArtifacts` off and the default `MERGE` / `EXACT`, which is what the report used — and what proves the `available-at` redirects are recorded and reach the duplicate handling regardless of the flag. --- .../MergePlatformArtifactsFunctionalTest.kt | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt index dacad840b..3708186b1 100644 --- a/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt +++ b/plugin-build/plugin/src/test/kotlin/com/mikepenz/aboutlibraries/plugin/MergePlatformArtifactsFunctionalTest.kt @@ -130,6 +130,35 @@ class MergePlatformArtifactsFunctionalTest { assertEquals(setOf("iosSimulatorArm64", "jvm"), targetsOf(merged), "Entry: $merged") } + /** + * https://github.com/mikepenz/AboutLibraries/issues/1430 — end to end, with a real resolution + * rather than a hand-fed redirect map. + * + * `com.materialkolor:material-kolor` and `com.materialkolor:material-color-utilities` publish + * the same POM `name` ("MaterialKolor") and `description`, so `DuplicateRule.EXACT` considers + * them equal and the default `DuplicateMode.MERGE` collapsed them onto one entry — dropping a + * library the build actually depends on. Only the platform artifacts of one module may merge. + * + * Runs with `mergePlatformArtifacts` **off**: that is the default configuration, and the one + * the report came from. It is also what proves the `available-at` redirects are recorded (and + * reach the duplicate handling) regardless of the flag. + */ + @Test + fun `sibling modules sharing name and description are both reported`() { + val json = runExport( + mergePlatformArtifacts = false, + dependencies = listOf("com.materialkolor:material-kolor:5.0.0"), + duplicationMode = DuplicateMode.MERGE, + ) + val reported = Regex("\"uniqueId\":\"(com\\.materialkolor:[^\"]*)\"").findAll(json).map { it.groupValues[1] }.toSet() + + assertEquals( + setOf("com.materialkolor:material-kolor", "com.materialkolor:material-color-utilities"), + reported, + "both modules must survive, each under the coordinate that was declared. Output:\n$json", + ) + } + private fun targetsOf(entry: String): Set = Regex("\"targets\":\\[(.*?)]").find(entry)?.groupValues?.get(1) ?.split(",")?.mapNotNull { it.trim().trim('"').takeIf(String::isNotEmpty) }?.toSet() @@ -221,6 +250,7 @@ class MergePlatformArtifactsFunctionalTest { private fun runExport( mergePlatformArtifacts: Boolean, dependencies: List = listOf("androidx.collection:collection:1.5.0", "androidx.annotation:annotation-jvm:1.9.1"), + duplicationMode: DuplicateMode = DuplicateMode.KEEP, ): String { File(projectDir, "settings.gradle.kts").writeText("""rootProject.name = "test-project"""") File(projectDir, "build.gradle.kts").writeText( @@ -243,7 +273,7 @@ class MergePlatformArtifactsFunctionalTest { offlineMode = true library { mergePlatformArtifacts = $mergePlatformArtifacts - duplicationMode = com.mikepenz.aboutlibraries.plugin.DuplicateMode.KEEP + duplicationMode = com.mikepenz.aboutlibraries.plugin.DuplicateMode.$duplicationMode } } """.trimIndent() From 6edf6188517fd775af39d3b734dff4bd21d49e6e Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 17:04:52 +0200 Subject: [PATCH 6/7] chore(sample): regenerate aboutlibraries.json for all samples MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Platform artifacts are now reported under the root coordinate they redirect from, so ids match what the build scripts declare (`androidx.collection:collection` rather than `collection-jvm` / `collection-android`). - `com.github.skydoves:compose-stability-runtime-*` drops out: the stability analyzer is no longer applied to the samples, so it is not on their classpath. Unrelated to the id changes — regenerating on `develop` drops it too. - web sample loses `org.jetbrains.compose.components:components-resources-wasmJs` as a separate entry: it is a platform artifact of `components-resources`, which the previous suffix matching missed because of the camelCase `wasmJs`. No library is lost otherwise — entry counts are unchanged for every other sample. --- app-test/files/jvm/aboutlibraries.json | 107 ++++---- app-test/files/wasmJs/aboutlibraries.json | 56 ++-- .../files/aboutlibraries.json | 177 ++++++------ .../files/aboutlibraries.json | 200 +++++++------- .../files/aboutlibraries.json | 253 ++++++++---------- 5 files changed, 393 insertions(+), 400 deletions(-) diff --git a/app-test/files/jvm/aboutlibraries.json b/app-test/files/jvm/aboutlibraries.json index c5eb6a6e9..560e023be 100644 --- a/app-test/files/jvm/aboutlibraries.json +++ b/app-test/files/jvm/aboutlibraries.json @@ -2,106 +2,115 @@ "libraries": [ { "uniqueId": "javax.annotation:javax.annotation-api", - "funding": [ - - ], + "artifactVersion": "1.3.2", + "name": "javax.annotation API", + "description": "Common Annotations for the JavaTM Platform API", + "website": "http://jcp.org/en/jsr/detail?id=250", "developers": [ { "name": "Linda De Michiel" } ], - "artifactVersion": "1.3.2", - "description": "Common Annotations for the JavaTM Platform API", + "organization": { + "name": "GlassFish Community", + "url": "https://javaee.github.io/glassfish" + }, "scm": { "connection": "scm:git:https://github.com/javaee/javax.annotation.git", - "url": "https://github.com/javaee/javax.annotation", - "developerConnection": "scm:git:git@github.com:javaee/javax.annotation.git" + "developerConnection": "scm:git:git@github.com:javaee/javax.annotation.git", + "url": "https://github.com/javaee/javax.annotation" }, - "name": "javax.annotation API", - "website": "http://jcp.org/en/jsr/detail?id=250", "licenses": [ "e1692074a62fa0fd6ef3ef00ec4904f0", "9be0c4d7964ad9a68deb2e9706266b8c" ], - "organization": { - "url": "https://javaee.github.io/glassfish", - "name": "GlassFish Community" - } - }, - { - "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", "funding": [ ], + "targets": [ + "jvm" + ] + }, + { + "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", + "artifactVersion": "2.4.10", + "name": "Kotlin Stdlib", + "description": "Kotlin Standard Library", + "website": "https://kotlinlang.org/", "developers": [ { - "organisationUrl": "https://www.jetbrains.com", - "name": "Kotlin Team" + "name": "Kotlin Team", + "organisationUrl": "https://www.jetbrains.com" } ], - "artifactVersion": "2.1.21", - "description": "Kotlin Standard Library", "scm": { "connection": "scm:git:https://github.com/JetBrains/kotlin.git", - "url": "https://github.com/JetBrains/kotlin", - "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git" + "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git", + "url": "https://github.com/JetBrains/kotlin" }, - "name": "Kotlin Stdlib", - "website": "https://kotlinlang.org/", "licenses": [ "Apache-2.0" + ], + "funding": [ + + ], + "targets": [ + "jvm" ] }, { "uniqueId": "org.jetbrains:annotations", - "funding": [ - - ], + "artifactVersion": "13.0", + "name": "IntelliJ IDEA Annotations", + "description": "A set of annotations used for code inspection support and code documentation.", + "website": "http://www.jetbrains.org", "developers": [ { - "organisationUrl": "http://www.jetbrains.com", - "name": "JetBrains Team" + "name": "JetBrains Team", + "organisationUrl": "http://www.jetbrains.com" } ], - "artifactVersion": "13.0", - "description": "A set of annotations used for code inspection support and code documentation.", "scm": { "connection": "scm:git:https://github.com/JetBrains/intellij-community.git", "url": "https://github.com/JetBrains/intellij-community" }, - "name": "IntelliJ IDEA Annotations", - "website": "http://www.jetbrains.org", "licenses": [ - "196b44647f01b6b79fdfedf9cd2caed7" + "Apache-2.0", + "fea9e903303ed8cbc7854c24956a8913" + ], + "funding": [ + + ], + "targets": [ + "jvm" ] } ], "licenses": { - "196b44647f01b6b79fdfedf9cd2caed7": { - "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.", - "hash": "196b44647f01b6b79fdfedf9cd2caed7", - "url": "https://raw.githubusercontent.com/JetBrains/intellij-community/master/LICENSE.txt", - "spdxId": "Apache-2.0", - "name": "Apache License 2.0" - }, "9be0c4d7964ad9a68deb2e9706266b8c": { - "hash": "9be0c4d7964ad9a68deb2e9706266b8c", + "name": "CDDL + GPLv2 with classpath exception", "url": "https://github.com/javaee/javax.annotation/blob/master/LICENSE", - "name": "CDDL + GPLv2 with classpath exception" + "hash": "9be0c4d7964ad9a68deb2e9706266b8c" }, "Apache-2.0": { + "name": "Apache License 2.0", + "url": "https://spdx.org/licenses/Apache-2.0.html", "content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\nTo apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.", - "hash": "Apache-2.0", "internalHash": "Apache-2.0", - "url": "https://spdx.org/licenses/Apache-2.0.html", "spdxId": "Apache-2.0", - "name": "Apache License 2.0" + "hash": "Apache-2.0" }, "e1692074a62fa0fd6ef3ef00ec4904f0": { - "content": "COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.1\n\n1. Definitions.\n\n 1.1. \"Contributor\" means each individual or entity that creates or\n contributes to the creation of Modifications.\n\n 1.2. \"Contributor Version\" means the combination of the Original\n Software, prior Modifications used by a Contributor (if any), and\n the Modifications made by that particular Contributor.\n\n 1.3. \"Covered Software\" means (a) the Original Software, or (b)\n Modifications, or (c) the combination of files containing Original\n Software with files containing Modifications, in each case including\n portions thereof.\n\n 1.4. \"Executable\" means the Covered Software in any form other than\n Source Code.\n\n 1.5. \"Initial Developer\" means the individual or entity that first\n makes Original Software available under this License.\n\n 1.6. \"Larger Work\" means a work which combines Covered Software or\n portions thereof with code not governed by the terms of this License.\n\n 1.7. \"License\" means this document.\n\n 1.8. \"Licensable\" means having the right to grant, to the maximum\n extent possible, whether at the time of the initial grant or\n subsequently acquired, any and all of the rights conveyed herein.\n\n 1.9. \"Modifications\" means the Source Code and Executable form of\n any of the following:\n\n A. Any file that results from an addition to, deletion from or\n modification of the contents of a file containing Original Software\n or previous Modifications;\n\n B. Any new file that contains any part of the Original Software or\n previous Modification; or\n\n C. Any new file that is contributed or otherwise made available\n under the terms of this License.\n\n 1.10. \"Original Software\" means the Source Code and Executable form\n of computer software code that is originally released under this\n License.\n\n 1.11. \"Patent Claims\" means any patent claim(s), now owned or\n hereafter acquired, including without limitation, method, process,\n and apparatus claims, in any patent Licensable by grantor.\n\n 1.12. \"Source Code\" means (a) the common form of computer software\n code in which modifications are made and (b) associated\n documentation included in or with such code.\n\n 1.13. \"You\" (or \"Your\") means an individual or a legal entity\n exercising rights under, and complying with all of the terms of,\n this License. For legal entities, \"You\" includes any entity which\n controls, is controlled by, or is under common control with You. For\n purposes of this definition, \"control\" means (a) the power, direct\n or indirect, to cause the direction or management of such entity,\n whether by contract or otherwise, or (b) ownership of more than\n fifty percent (50%) of the outstanding shares or beneficial\n ownership of such entity.\n\n2. License Grants.\n\n 2.1. The Initial Developer Grant.\n\n Conditioned upon Your compliance with Section 3.1 below and subject\n to third party intellectual property claims, the Initial Developer\n hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n (a) under intellectual property rights (other than patent or\n trademark) Licensable by Initial Developer, to use, reproduce,\n modify, display, perform, sublicense and distribute the Original\n Software (or portions thereof), with or without Modifications,\n and/or as part of a Larger Work; and\n\n (b) under Patent Claims infringed by the making, using or selling of\n Original Software, to make, have made, use, practice, sell, and\n offer for sale, and/or otherwise dispose of the Original Software\n (or portions thereof).\n\n (c) The licenses granted in Sections 2.1(a) and (b) are effective on\n the date Initial Developer first distributes or otherwise makes the\n Original Software available to a third party under the terms of this\n License.\n\n (d) Notwithstanding Section 2.1(b) above, no patent license is\n granted: (1) for code that You delete from the Original Software, or\n (2) for infringements caused by: (i) the modification of the\n Original Software, or (ii) the combination of the Original Software\n with other software or devices.\n\n 2.2. Contributor Grant.\n\n Conditioned upon Your compliance with Section 3.1 below and subject\n to third party intellectual property claims, each Contributor hereby\n grants You a world-wide, royalty-free, non-exclusive license:\n\n (a) under intellectual property rights (other than patent or\n trademark) Licensable by Contributor to use, reproduce, modify,\n display, perform, sublicense and distribute the Modifications\n created by such Contributor (or portions thereof), either on an\n unmodified basis, with other Modifications, as Covered Software\n and/or as part of a Larger Work; and\n\n (b) under Patent Claims infringed by the making, using, or selling\n of Modifications made by that Contributor either alone and/or in\n combination with its Contributor Version (or portions of such\n combination), to make, use, sell, offer for sale, have made, and/or\n otherwise dispose of: (1) Modifications made by that Contributor (or\n portions thereof); and (2) the combination of Modifications made by\n that Contributor with its Contributor Version (or portions of such\n combination).\n\n (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective\n on the date Contributor first distributes or otherwise makes the\n Modifications available to a third party.\n\n (d) Notwithstanding Section 2.2(b) above, no patent license is\n granted: (1) for any code that Contributor has deleted from the\n Contributor Version; (2) for infringements caused by: (i) third\n party modifications of Contributor Version, or (ii) the combination\n of Modifications made by that Contributor with other software\n (except as part of the Contributor Version) or other devices; or (3)\n under Patent Claims infringed by Covered Software in the absence of\n Modifications made by that Contributor.\n\n3. Distribution Obligations.\n\n 3.1. Availability of Source Code.\n\n Any Covered Software that You distribute or otherwise make available\n in Executable form must also be made available in Source Code form\n and that Source Code form must be distributed only under the terms\n of this License. You must include a copy of this License with every\n copy of the Source Code form of the Covered Software You distribute\n or otherwise make available. You must inform recipients of any such\n Covered Software in Executable form as to how they can obtain such\n Covered Software in Source Code form in a reasonable manner on or\n through a medium customarily used for software exchange.\n\n 3.2. Modifications.\n\n The Modifications that You create or to which You contribute are\n governed by the terms of this License. You represent that You\n believe Your Modifications are Your original creation(s) and/or You\n have sufficient rights to grant the rights conveyed by this License.\n\n 3.3. Required Notices.\n\n You must include a notice in each of Your Modifications that\n identifies You as the Contributor of the Modification. You may not\n remove or alter any copyright, patent or trademark notices contained\n within the Covered Software, or any notices of licensing or any\n descriptive text giving attribution to any Contributor or the\n Initial Developer.\n\n 3.4. Application of Additional Terms.\n\n You may not offer or impose any terms on any Covered Software in\n Source Code form that alters or restricts the applicable version of\n this License or the recipients' rights hereunder. You may choose to\n offer, and to charge a fee for, warranty, support, indemnity or\n liability obligations to one or more recipients of Covered Software.\n However, you may do so only on Your own behalf, and not on behalf of\n the Initial Developer or any Contributor. You must make it\n absolutely clear that any such warranty, support, indemnity or\n liability obligation is offered by You alone, and You hereby agree\n to indemnify the Initial Developer and every Contributor for any\n liability incurred by the Initial Developer or such Contributor as a\n result of warranty, support, indemnity or liability terms You offer.\n\n 3.5. Distribution of Executable Versions.\n\n You may distribute the Executable form of the Covered Software under\n the terms of this License or under the terms of a license of Your\n choice, which may contain terms different from this License,\n provided that You are in compliance with the terms of this License\n and that the license for the Executable form does not attempt to\n limit or alter the recipient's rights in the Source Code form from\n the rights set forth in this License. If You distribute the Covered\n Software in Executable form under a different license, You must make\n it absolutely clear that any terms which differ from this License\n are offered by You alone, not by the Initial Developer or\n Contributor. You hereby agree to indemnify the Initial Developer and\n every Contributor for any liability incurred by the Initial\n Developer or such Contributor as a result of any such terms You offer.\n\n 3.6. Larger Works.\n\n You may create a Larger Work by combining Covered Software with\n other code not governed by the terms of this License and distribute\n the Larger Work as a single product. In such a case, You must make\n sure the requirements of this License are fulfilled for the Covered\n Software.\n\n4. Versions of the License.\n\n 4.1. New Versions.\n\n Oracle is the initial license steward and may publish revised and/or\n new versions of this License from time to time. Each version will be\n given a distinguishing version number. Except as provided in Section\n 4.3, no one other than the license steward has the right to modify\n this License.\n\n 4.2. Effect of New Versions.\n\n You may always continue to use, distribute or otherwise make the\n Covered Software available under the terms of the version of the\n License under which You originally received the Covered Software. If\n the Initial Developer includes a notice in the Original Software\n prohibiting it from being distributed or otherwise made available\n under any subsequent version of the License, You must distribute and\n make the Covered Software available under the terms of the version\n of the License under which You originally received the Covered\n Software. Otherwise, You may also choose to use, distribute or\n otherwise make the Covered Software available under the terms of any\n subsequent version of the License published by the license steward.\n\n 4.3. Modified Versions.\n\n When You are an Initial Developer and You want to create a new\n license for Your Original Software, You may create and use a\n modified version of this License if You: (a) rename the license and\n remove any references to the name of the license steward (except to\n note that the license differs from this License); and (b) otherwise\n make it clear that the license contains terms which differ from this\n License.\n\n5. DISCLAIMER OF WARRANTY.\n\n COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS,\n WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,\n INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE\n IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR\n NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF\n THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE\n DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY\n OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING,\n REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN\n ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS\n AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n6. TERMINATION.\n\n 6.1. This License and the rights granted hereunder will terminate\n automatically if You fail to comply with terms herein and fail to\n cure such breach within 30 days of becoming aware of the breach.\n Provisions which, by their nature, must remain in effect beyond the\n termination of this License shall survive.\n\n 6.2. If You assert a patent infringement claim (excluding\n declaratory judgment actions) against Initial Developer or a\n Contributor (the Initial Developer or Contributor against whom You\n assert such claim is referred to as \"Participant\") alleging that the\n Participant Software (meaning the Contributor Version where the\n Participant is a Contributor or the Original Software where the\n Participant is the Initial Developer) directly or indirectly\n infringes any patent, then any and all rights granted directly or\n indirectly to You by such Participant, the Initial Developer (if the\n Initial Developer is not the Participant) and all Contributors under\n Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice\n from Participant terminate prospectively and automatically at the\n expiration of such 60 day notice period, unless if within such 60\n day period You withdraw Your claim with respect to the Participant\n Software against such Participant either unilaterally or pursuant to\n a written agreement with Participant.\n\n 6.3. If You assert a patent infringement claim against Participant\n alleging that the Participant Software directly or indirectly\n infringes any patent where such claim is resolved (such as by\n license or settlement) prior to the initiation of patent\n infringement litigation, then the reasonable value of the licenses\n granted by such Participant under Sections 2.1 or 2.2 shall be taken\n into account in determining the amount or value of any payment or\n license.\n\n 6.4. In the event of termination under Sections 6.1 or 6.2 above,\n all end user licenses that have been validly granted by You or any\n distributor hereunder prior to termination (excluding licenses\n granted to You by any distributor) shall survive termination.\n\n7. LIMITATION OF LIABILITY.\n\n UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT\n (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE\n INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF\n COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE\n TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR\n CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT\n LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER\n FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR\n LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE\n POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT\n APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH\n PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH\n LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR\n LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION\n AND LIMITATION MAY NOT APPLY TO YOU.\n\n8. U.S. GOVERNMENT END USERS.\n\n The Covered Software is a \"commercial item,\" as that term is defined\n in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer\n software\" (as that term is defined at 48 C.F.R. \u00a7\n 252.227-7014(a)(1)) and \"commercial computer software documentation\"\n as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent\n with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4\n (June 1995), all U.S. Government End Users acquire Covered Software\n with only those rights set forth herein. This U.S. Government Rights\n clause is in lieu of, and supersedes, any other FAR, DFAR, or other\n clause or provision that addresses Government rights in computer\n software under this License.\n\n9. MISCELLANEOUS.\n\n This License represents the complete agreement concerning subject\n matter hereof. If any provision of this License is held to be\n unenforceable, such provision shall be reformed only to the extent\n necessary to make it enforceable. This License shall be governed by\n the law of the jurisdiction specified in a notice contained within\n the Original Software (except to the extent applicable law, if any,\n provides otherwise), excluding such jurisdiction's conflict-of-law\n provisions. Any litigation relating to this License shall be subject\n to the jurisdiction of the courts located in the jurisdiction and\n venue specified in a notice contained within the Original Software,\n with the losing party responsible for costs, including, without\n limitation, court costs and reasonable attorneys' fees and expenses.\n The application of the United Nations Convention on Contracts for\n the International Sale of Goods is expressly excluded. Any law or\n regulation which provides that the language of a contract shall be\n construed against the drafter shall not apply to this License. You\n agree that You alone are responsible for compliance with the United\n States export administration regulations (and the export control\n laws and regulation of any other countries) when You use, distribute\n or otherwise make available any Covered Software.\n\n10. RESPONSIBILITY FOR CLAIMS.\n\n As between Initial Developer and the Contributors, each party is\n responsible for claims and damages arising, directly or indirectly,\n out of its utilization of rights under this License and You agree to\n work with Initial Developer and Contributors to distribute such\n responsibility on an equitable basis. Nothing herein is intended or\n shall be deemed to constitute any admission of liability.\n\n------------------------------------------------------------------------\n\nNOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION\nLICENSE (CDDL)\n\nThe code released under the CDDL shall be governed by the laws of the\nState of California (excluding conflict-of-law provisions). Any\nlitigation relating to this License shall be subject to the jurisdiction\nof the Federal Courts of the Northern District of California and the\nstate courts of the State of California, with venue lying in Santa Clara\nCounty, California.\n\n\n\n The GNU General Public License (GPL) Version 2, June 1991\n\nCopyright (C) 1989, 1991 Free Software Foundation, Inc.\n51 Franklin Street, Fifth Floor\nBoston, MA 02110-1335\nUSA\n\nEveryone is permitted to copy and distribute verbatim copies\nof this license document, but changing it is not allowed.\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to\nshare and change it. By contrast, the GNU General Public License is\nintended to guarantee your freedom to share and change free software--to\nmake sure the software is free for all its users. This General Public\nLicense applies to most of the Free Software Foundation's software and\nto any other program whose authors commit to using it. (Some other Free\nSoftware Foundation software is covered by the GNU Library General\nPublic License instead.) You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price.\nOur General Public Licenses are designed to make sure that you have the\nfreedom to distribute copies of free software (and charge for this\nservice if you wish), that you receive source code or can get it if you\nwant it, that you can change the software or use pieces of it in new\nfree programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone\nto deny you these rights or to ask you to surrender the rights. These\nrestrictions translate to certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of such a program, whether gratis\nor for a fee, you must give the recipients all the rights that you have.\nYou must make sure that they, too, receive or can get the source code.\nAnd you must show them these terms so they know their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\nFinally, any free program is threatened constantly by software patents.\nWe wish to avoid the danger that redistributors of a free program will\nindividually obtain patent licenses, in effect making the program\nproprietary. To prevent this, we have made it clear that any patent must\nbe licensed for everyone's free use or not licensed at all.\n\nThe precise terms and conditions for copying, distribution and\nmodification follow.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n0. This License applies to any program or other work which contains a\nnotice placed by the copyright holder saying it may be distributed under\nthe terms of this General Public License. The \"Program\", below, refers\nto any such program or work, and a \"work based on the Program\" means\neither the Program or any derivative work under copyright law: that is\nto say, a work containing the Program or a portion of it, either\nverbatim or with modifications and/or translated into another language.\n(Hereinafter, translation is included without limitation in the term\n\"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of running\nthe Program is not restricted, and the output from the Program is\ncovered only if its contents constitute a work based on the Program\n(independent of having been made by running the Program). Whether that\nis true depends on what the Program does.\n\n1. You may copy and distribute verbatim copies of the Program's source\ncode as you receive it, in any medium, provided that you conspicuously\nand appropriately publish on each copy an appropriate copyright notice\nand disclaimer of warranty; keep intact all the notices that refer to\nthis License and to the absence of any warranty; and give any other\nrecipients of the Program a copy of this License along with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n2. You may modify your copy or copies of the Program or any portion of\nit, thus forming a work based on the Program, and copy and distribute\nsuch modifications or work under the terms of Section 1 above, provided\nthat you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any part\n thereof, to be licensed as a whole at no charge to all third parties\n under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a notice\n that there is no warranty (or else, saying that you provide a\n warranty) and that users may redistribute the program under these\n conditions, and telling the user how to view a copy of this License.\n (Exception: if the Program itself is interactive but does not\n normally print such an announcement, your work based on the Program\n is not required to print an announcement.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program, and\ncan be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based on\nthe Program, the distribution of the whole must be on the terms of this\nLicense, whose permissions for other licensees extend to the entire\nwhole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of a\nstorage or distribution medium does not bring the other work under the\nscope of this License.\n\n3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections 1\n and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your cost\n of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer to\n distribute corresponding source code. (This alternative is allowed\n only for noncommercial distribution and only if you received the\n program in object code or executable form with such an offer, in\n accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source code\nmeans all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to control\ncompilation and installation of the executable. However, as a special\nexception, the source code distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies the\nexecutable.\n\nIf distribution of executable or object code is made by offering access\nto copy from a designated place, then offering equivalent access to copy\nthe source code from the same place counts as distribution of the source\ncode, even though third parties are not compelled to copy the source\nalong with the object code.\n\n4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt otherwise\nto copy, modify, sublicense or distribute the Program is void, and will\nautomatically terminate your rights under this License. However, parties\nwho have received copies, or rights, from you under this License will\nnot have their licenses terminated so long as such parties remain in\nfull compliance.\n\n5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and all\nits terms and conditions for copying, distributing or modifying the\nProgram or works based on it.\n\n6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further restrictions\non the recipients' exercise of the rights granted herein. You are not\nresponsible for enforcing compliance by third parties to this License.\n\n7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot distribute\nso as to satisfy simultaneously your obligations under this License and\nany other pertinent obligations, then as a consequence you may not\ndistribute the Program at all. For example, if a patent license would\nnot permit royalty-free redistribution of the Program by all those who\nreceive copies directly or indirectly through you, then the only way you\ncould satisfy both it and this License would be to refrain entirely from\ndistribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is implemented\nby public license practices. Many people have made generous\ncontributions to the wide range of software distributed through that\nsystem in reliance on consistent application of that system; it is up to\nthe author/donor to decide if he or she is willing to distribute\nsoftware through any other system and a licensee cannot impose that choice.\n\nThis section is intended to make thoroughly clear what is believed to be\na consequence of the rest of this License.\n\n8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License may\nadd an explicit geographical distribution limitation excluding those\ncountries, so that distribution is permitted only in or among countries\nnot thus excluded. In such case, this License incorporates the\nlimitation as if written in the body of this License.\n\n9. The Free Software Foundation may publish revised and/or new\nversions of the General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Program does not specify a version\nnumber of this License, you may choose any version ever published by the\nFree Software Foundation.\n\n10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the\nauthor to ask for permission. For software which is copyrighted by the\nFree Software Foundation, write to the Free Software Foundation; we\nsometimes make exceptions for this. Our decision will be guided by the\ntwo goals of preserving the free status of all derivatives of our free\nsoftware and of promoting the sharing and reuse of software generally.\n\nNO WARRANTY\n\n11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND,\nEITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE\nENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH\nYOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL\nNECESSARY SERVICING, REPAIR OR CORRECTION.\n\n12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR\nDAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL\nDAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM\n(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED\nINACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF\nTHE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR\nOTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nEND OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to\nattach them to the start of each source file to most effectively convey\nthe exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n One line to give the program's name and a brief idea of what it does.\n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this\nwhen it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type\n `show w'. This is free software, and you are welcome to redistribute\n it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the\nappropriate parts of the General Public License. Of course, the commands\nyou use may be called something other than `show w' and `show c'; they\ncould even be mouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the program, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n program `Gnomovision' (which makes passes at compilers) written by\n James Hacker.\n\n signature of Ty Coon, 1 April 1989\n Ty Coon, President of Vice\n\nThis General Public License does not permit incorporating your program\ninto proprietary programs. If your program is a subroutine library, you\nmay consider it more useful to permit linking proprietary applications\nwith the library. If this is what you want to do, use the GNU Library\nGeneral Public License instead of this License.\n\n#\n\nCertain source files distributed by Oracle America, Inc. and/or its\naffiliates are subject to the following clarification and special\nexception to the GPLv2, based on the GNU Project exception for its\nClasspath libraries, known as the GNU Classpath Exception, but only\nwhere Oracle has expressly included in the particular source file's\nheader the words \"Oracle designates this particular file as subject to\nthe \"Classpath\" exception as provided by Oracle in the LICENSE file\nthat accompanied this code.\"\n\nYou should also note that Oracle includes multiple, independent\nprograms in this software package. Some of those programs are provided\nunder licenses deemed incompatible with the GPLv2 by the Free Software\nFoundation and others. For example, the package includes programs\nlicensed under the Apache License, Version 2.0. Such programs are\nlicensed to you under their original licenses.\n\nOracle facilitates your further distribution of this package by adding\nthe Classpath Exception to the necessary parts of its GPLv2 code, which\npermits you to use that code in combination with other independent\nmodules not licensed under the GPLv2. However, note that this would\nnot permit you to commingle code under an incompatible license with\nOracle's GPLv2 licensed code by, for example, cutting and pasting such\ncode into a file also containing Oracle's GPLv2 licensed code and then\ndistributing the result. Additionally, if you were to remove the\nClasspath Exception from any of the files to which it applies and\ndistribute the result, you would likely be required to license some or\nall of the other code in that distribution under the GPLv2 as well, and\nsince the GPLv2 is incompatible with the license terms of some items\nincluded in the distribution by Oracle, removing the Classpath\nException could therefore effectively compromise your ability to\nfurther distribute the package.\n\nProceed with caution and we recommend that you obtain the advice of a\nlawyer skilled in open source matters before removing the Classpath\nException or making modifications to this package which may\nsubsequently be redistributed and/or involve the use of third party\nsoftware.\n\nCLASSPATH EXCEPTION\nLinking this library statically or dynamically with other modules is\nmaking a combined work based on this library. Thus, the terms and\nconditions of the GNU General Public License version 2 cover the whole\ncombination.\n\nAs a special exception, the copyright holders of this library give you\npermission to link this library with independent modules to produce an\nexecutable, regardless of the license terms of these independent\nmodules, and to copy and distribute the resulting executable under\nterms of your choice, provided that you also meet, for each linked\nindependent module, the terms and conditions of the license of that\nmodule. An independent module is a module which is not derived from or\nbased on this library. If you modify this library, you may extend this\nexception to your version of the library, but you are not obligated to\ndo so. If you do not wish to do so, delete this exception statement\nfrom your version.", - "hash": "e1692074a62fa0fd6ef3ef00ec4904f0", + "name": "Other", "url": "https://raw.githubusercontent.com/javaee/javax.annotation/master/LICENSE", - "name": "Other" + "content": "COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.1\n\n1. Definitions.\n\n 1.1. \"Contributor\" means each individual or entity that creates or\n contributes to the creation of Modifications.\n\n 1.2. \"Contributor Version\" means the combination of the Original\n Software, prior Modifications used by a Contributor (if any), and\n the Modifications made by that particular Contributor.\n\n 1.3. \"Covered Software\" means (a) the Original Software, or (b)\n Modifications, or (c) the combination of files containing Original\n Software with files containing Modifications, in each case including\n portions thereof.\n\n 1.4. \"Executable\" means the Covered Software in any form other than\n Source Code.\n\n 1.5. \"Initial Developer\" means the individual or entity that first\n makes Original Software available under this License.\n\n 1.6. \"Larger Work\" means a work which combines Covered Software or\n portions thereof with code not governed by the terms of this License.\n\n 1.7. \"License\" means this document.\n\n 1.8. \"Licensable\" means having the right to grant, to the maximum\n extent possible, whether at the time of the initial grant or\n subsequently acquired, any and all of the rights conveyed herein.\n\n 1.9. \"Modifications\" means the Source Code and Executable form of\n any of the following:\n\n A. Any file that results from an addition to, deletion from or\n modification of the contents of a file containing Original Software\n or previous Modifications;\n\n B. Any new file that contains any part of the Original Software or\n previous Modification; or\n\n C. Any new file that is contributed or otherwise made available\n under the terms of this License.\n\n 1.10. \"Original Software\" means the Source Code and Executable form\n of computer software code that is originally released under this\n License.\n\n 1.11. \"Patent Claims\" means any patent claim(s), now owned or\n hereafter acquired, including without limitation, method, process,\n and apparatus claims, in any patent Licensable by grantor.\n\n 1.12. \"Source Code\" means (a) the common form of computer software\n code in which modifications are made and (b) associated\n documentation included in or with such code.\n\n 1.13. \"You\" (or \"Your\") means an individual or a legal entity\n exercising rights under, and complying with all of the terms of,\n this License. For legal entities, \"You\" includes any entity which\n controls, is controlled by, or is under common control with You. For\n purposes of this definition, \"control\" means (a) the power, direct\n or indirect, to cause the direction or management of such entity,\n whether by contract or otherwise, or (b) ownership of more than\n fifty percent (50%) of the outstanding shares or beneficial\n ownership of such entity.\n\n2. License Grants.\n\n 2.1. The Initial Developer Grant.\n\n Conditioned upon Your compliance with Section 3.1 below and subject\n to third party intellectual property claims, the Initial Developer\n hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n (a) under intellectual property rights (other than patent or\n trademark) Licensable by Initial Developer, to use, reproduce,\n modify, display, perform, sublicense and distribute the Original\n Software (or portions thereof), with or without Modifications,\n and/or as part of a Larger Work; and\n\n (b) under Patent Claims infringed by the making, using or selling of\n Original Software, to make, have made, use, practice, sell, and\n offer for sale, and/or otherwise dispose of the Original Software\n (or portions thereof).\n\n (c) The licenses granted in Sections 2.1(a) and (b) are effective on\n the date Initial Developer first distributes or otherwise makes the\n Original Software available to a third party under the terms of this\n License.\n\n (d) Notwithstanding Section 2.1(b) above, no patent license is\n granted: (1) for code that You delete from the Original Software, or\n (2) for infringements caused by: (i) the modification of the\n Original Software, or (ii) the combination of the Original Software\n with other software or devices.\n\n 2.2. Contributor Grant.\n\n Conditioned upon Your compliance with Section 3.1 below and subject\n to third party intellectual property claims, each Contributor hereby\n grants You a world-wide, royalty-free, non-exclusive license:\n\n (a) under intellectual property rights (other than patent or\n trademark) Licensable by Contributor to use, reproduce, modify,\n display, perform, sublicense and distribute the Modifications\n created by such Contributor (or portions thereof), either on an\n unmodified basis, with other Modifications, as Covered Software\n and/or as part of a Larger Work; and\n\n (b) under Patent Claims infringed by the making, using, or selling\n of Modifications made by that Contributor either alone and/or in\n combination with its Contributor Version (or portions of such\n combination), to make, use, sell, offer for sale, have made, and/or\n otherwise dispose of: (1) Modifications made by that Contributor (or\n portions thereof); and (2) the combination of Modifications made by\n that Contributor with its Contributor Version (or portions of such\n combination).\n\n (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective\n on the date Contributor first distributes or otherwise makes the\n Modifications available to a third party.\n\n (d) Notwithstanding Section 2.2(b) above, no patent license is\n granted: (1) for any code that Contributor has deleted from the\n Contributor Version; (2) for infringements caused by: (i) third\n party modifications of Contributor Version, or (ii) the combination\n of Modifications made by that Contributor with other software\n (except as part of the Contributor Version) or other devices; or (3)\n under Patent Claims infringed by Covered Software in the absence of\n Modifications made by that Contributor.\n\n3. Distribution Obligations.\n\n 3.1. Availability of Source Code.\n\n Any Covered Software that You distribute or otherwise make available\n in Executable form must also be made available in Source Code form\n and that Source Code form must be distributed only under the terms\n of this License. You must include a copy of this License with every\n copy of the Source Code form of the Covered Software You distribute\n or otherwise make available. You must inform recipients of any such\n Covered Software in Executable form as to how they can obtain such\n Covered Software in Source Code form in a reasonable manner on or\n through a medium customarily used for software exchange.\n\n 3.2. Modifications.\n\n The Modifications that You create or to which You contribute are\n governed by the terms of this License. You represent that You\n believe Your Modifications are Your original creation(s) and/or You\n have sufficient rights to grant the rights conveyed by this License.\n\n 3.3. Required Notices.\n\n You must include a notice in each of Your Modifications that\n identifies You as the Contributor of the Modification. You may not\n remove or alter any copyright, patent or trademark notices contained\n within the Covered Software, or any notices of licensing or any\n descriptive text giving attribution to any Contributor or the\n Initial Developer.\n\n 3.4. Application of Additional Terms.\n\n You may not offer or impose any terms on any Covered Software in\n Source Code form that alters or restricts the applicable version of\n this License or the recipients' rights hereunder. You may choose to\n offer, and to charge a fee for, warranty, support, indemnity or\n liability obligations to one or more recipients of Covered Software.\n However, you may do so only on Your own behalf, and not on behalf of\n the Initial Developer or any Contributor. You must make it\n absolutely clear that any such warranty, support, indemnity or\n liability obligation is offered by You alone, and You hereby agree\n to indemnify the Initial Developer and every Contributor for any\n liability incurred by the Initial Developer or such Contributor as a\n result of warranty, support, indemnity or liability terms You offer.\n\n 3.5. Distribution of Executable Versions.\n\n You may distribute the Executable form of the Covered Software under\n the terms of this License or under the terms of a license of Your\n choice, which may contain terms different from this License,\n provided that You are in compliance with the terms of this License\n and that the license for the Executable form does not attempt to\n limit or alter the recipient's rights in the Source Code form from\n the rights set forth in this License. If You distribute the Covered\n Software in Executable form under a different license, You must make\n it absolutely clear that any terms which differ from this License\n are offered by You alone, not by the Initial Developer or\n Contributor. You hereby agree to indemnify the Initial Developer and\n every Contributor for any liability incurred by the Initial\n Developer or such Contributor as a result of any such terms You offer.\n\n 3.6. Larger Works.\n\n You may create a Larger Work by combining Covered Software with\n other code not governed by the terms of this License and distribute\n the Larger Work as a single product. In such a case, You must make\n sure the requirements of this License are fulfilled for the Covered\n Software.\n\n4. Versions of the License.\n\n 4.1. New Versions.\n\n Oracle is the initial license steward and may publish revised and/or\n new versions of this License from time to time. Each version will be\n given a distinguishing version number. Except as provided in Section\n 4.3, no one other than the license steward has the right to modify\n this License.\n\n 4.2. Effect of New Versions.\n\n You may always continue to use, distribute or otherwise make the\n Covered Software available under the terms of the version of the\n License under which You originally received the Covered Software. If\n the Initial Developer includes a notice in the Original Software\n prohibiting it from being distributed or otherwise made available\n under any subsequent version of the License, You must distribute and\n make the Covered Software available under the terms of the version\n of the License under which You originally received the Covered\n Software. Otherwise, You may also choose to use, distribute or\n otherwise make the Covered Software available under the terms of any\n subsequent version of the License published by the license steward.\n\n 4.3. Modified Versions.\n\n When You are an Initial Developer and You want to create a new\n license for Your Original Software, You may create and use a\n modified version of this License if You: (a) rename the license and\n remove any references to the name of the license steward (except to\n note that the license differs from this License); and (b) otherwise\n make it clear that the license contains terms which differ from this\n License.\n\n5. DISCLAIMER OF WARRANTY.\n\n COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS,\n WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,\n INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE\n IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR\n NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF\n THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE\n DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY\n OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING,\n REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN\n ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS\n AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n6. TERMINATION.\n\n 6.1. This License and the rights granted hereunder will terminate\n automatically if You fail to comply with terms herein and fail to\n cure such breach within 30 days of becoming aware of the breach.\n Provisions which, by their nature, must remain in effect beyond the\n termination of this License shall survive.\n\n 6.2. If You assert a patent infringement claim (excluding\n declaratory judgment actions) against Initial Developer or a\n Contributor (the Initial Developer or Contributor against whom You\n assert such claim is referred to as \"Participant\") alleging that the\n Participant Software (meaning the Contributor Version where the\n Participant is a Contributor or the Original Software where the\n Participant is the Initial Developer) directly or indirectly\n infringes any patent, then any and all rights granted directly or\n indirectly to You by such Participant, the Initial Developer (if the\n Initial Developer is not the Participant) and all Contributors under\n Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice\n from Participant terminate prospectively and automatically at the\n expiration of such 60 day notice period, unless if within such 60\n day period You withdraw Your claim with respect to the Participant\n Software against such Participant either unilaterally or pursuant to\n a written agreement with Participant.\n\n 6.3. If You assert a patent infringement claim against Participant\n alleging that the Participant Software directly or indirectly\n infringes any patent where such claim is resolved (such as by\n license or settlement) prior to the initiation of patent\n infringement litigation, then the reasonable value of the licenses\n granted by such Participant under Sections 2.1 or 2.2 shall be taken\n into account in determining the amount or value of any payment or\n license.\n\n 6.4. In the event of termination under Sections 6.1 or 6.2 above,\n all end user licenses that have been validly granted by You or any\n distributor hereunder prior to termination (excluding licenses\n granted to You by any distributor) shall survive termination.\n\n7. LIMITATION OF LIABILITY.\n\n UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT\n (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE\n INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF\n COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE\n TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR\n CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT\n LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER\n FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR\n LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE\n POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT\n APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH\n PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH\n LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR\n LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION\n AND LIMITATION MAY NOT APPLY TO YOU.\n\n8. U.S. GOVERNMENT END USERS.\n\n The Covered Software is a \"commercial item,\" as that term is defined\n in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer\n software\" (as that term is defined at 48 C.F.R. \u00a7\n 252.227-7014(a)(1)) and \"commercial computer software documentation\"\n as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent\n with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4\n (June 1995), all U.S. Government End Users acquire Covered Software\n with only those rights set forth herein. This U.S. Government Rights\n clause is in lieu of, and supersedes, any other FAR, DFAR, or other\n clause or provision that addresses Government rights in computer\n software under this License.\n\n9. MISCELLANEOUS.\n\n This License represents the complete agreement concerning subject\n matter hereof. If any provision of this License is held to be\n unenforceable, such provision shall be reformed only to the extent\n necessary to make it enforceable. This License shall be governed by\n the law of the jurisdiction specified in a notice contained within\n the Original Software (except to the extent applicable law, if any,\n provides otherwise), excluding such jurisdiction's conflict-of-law\n provisions. Any litigation relating to this License shall be subject\n to the jurisdiction of the courts located in the jurisdiction and\n venue specified in a notice contained within the Original Software,\n with the losing party responsible for costs, including, without\n limitation, court costs and reasonable attorneys' fees and expenses.\n The application of the United Nations Convention on Contracts for\n the International Sale of Goods is expressly excluded. Any law or\n regulation which provides that the language of a contract shall be\n construed against the drafter shall not apply to this License. You\n agree that You alone are responsible for compliance with the United\n States export administration regulations (and the export control\n laws and regulation of any other countries) when You use, distribute\n or otherwise make available any Covered Software.\n\n10. RESPONSIBILITY FOR CLAIMS.\n\n As between Initial Developer and the Contributors, each party is\n responsible for claims and damages arising, directly or indirectly,\n out of its utilization of rights under this License and You agree to\n work with Initial Developer and Contributors to distribute such\n responsibility on an equitable basis. Nothing herein is intended or\n shall be deemed to constitute any admission of liability.\n\n------------------------------------------------------------------------\n\nNOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION\nLICENSE (CDDL)\n\nThe code released under the CDDL shall be governed by the laws of the\nState of California (excluding conflict-of-law provisions). Any\nlitigation relating to this License shall be subject to the jurisdiction\nof the Federal Courts of the Northern District of California and the\nstate courts of the State of California, with venue lying in Santa Clara\nCounty, California.\n\n\n\n The GNU General Public License (GPL) Version 2, June 1991\n\nCopyright (C) 1989, 1991 Free Software Foundation, Inc.\n51 Franklin Street, Fifth Floor\nBoston, MA 02110-1335\nUSA\n\nEveryone is permitted to copy and distribute verbatim copies\nof this license document, but changing it is not allowed.\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to\nshare and change it. By contrast, the GNU General Public License is\nintended to guarantee your freedom to share and change free software--to\nmake sure the software is free for all its users. This General Public\nLicense applies to most of the Free Software Foundation's software and\nto any other program whose authors commit to using it. (Some other Free\nSoftware Foundation software is covered by the GNU Library General\nPublic License instead.) You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price.\nOur General Public Licenses are designed to make sure that you have the\nfreedom to distribute copies of free software (and charge for this\nservice if you wish), that you receive source code or can get it if you\nwant it, that you can change the software or use pieces of it in new\nfree programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone\nto deny you these rights or to ask you to surrender the rights. These\nrestrictions translate to certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of such a program, whether gratis\nor for a fee, you must give the recipients all the rights that you have.\nYou must make sure that they, too, receive or can get the source code.\nAnd you must show them these terms so they know their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\nFinally, any free program is threatened constantly by software patents.\nWe wish to avoid the danger that redistributors of a free program will\nindividually obtain patent licenses, in effect making the program\nproprietary. To prevent this, we have made it clear that any patent must\nbe licensed for everyone's free use or not licensed at all.\n\nThe precise terms and conditions for copying, distribution and\nmodification follow.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n0. This License applies to any program or other work which contains a\nnotice placed by the copyright holder saying it may be distributed under\nthe terms of this General Public License. The \"Program\", below, refers\nto any such program or work, and a \"work based on the Program\" means\neither the Program or any derivative work under copyright law: that is\nto say, a work containing the Program or a portion of it, either\nverbatim or with modifications and/or translated into another language.\n(Hereinafter, translation is included without limitation in the term\n\"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of running\nthe Program is not restricted, and the output from the Program is\ncovered only if its contents constitute a work based on the Program\n(independent of having been made by running the Program). Whether that\nis true depends on what the Program does.\n\n1. You may copy and distribute verbatim copies of the Program's source\ncode as you receive it, in any medium, provided that you conspicuously\nand appropriately publish on each copy an appropriate copyright notice\nand disclaimer of warranty; keep intact all the notices that refer to\nthis License and to the absence of any warranty; and give any other\nrecipients of the Program a copy of this License along with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n2. You may modify your copy or copies of the Program or any portion of\nit, thus forming a work based on the Program, and copy and distribute\nsuch modifications or work under the terms of Section 1 above, provided\nthat you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any part\n thereof, to be licensed as a whole at no charge to all third parties\n under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a notice\n that there is no warranty (or else, saying that you provide a\n warranty) and that users may redistribute the program under these\n conditions, and telling the user how to view a copy of this License.\n (Exception: if the Program itself is interactive but does not\n normally print such an announcement, your work based on the Program\n is not required to print an announcement.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program, and\ncan be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based on\nthe Program, the distribution of the whole must be on the terms of this\nLicense, whose permissions for other licensees extend to the entire\nwhole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of a\nstorage or distribution medium does not bring the other work under the\nscope of this License.\n\n3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections 1\n and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your cost\n of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer to\n distribute corresponding source code. (This alternative is allowed\n only for noncommercial distribution and only if you received the\n program in object code or executable form with such an offer, in\n accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source code\nmeans all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to control\ncompilation and installation of the executable. However, as a special\nexception, the source code distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies the\nexecutable.\n\nIf distribution of executable or object code is made by offering access\nto copy from a designated place, then offering equivalent access to copy\nthe source code from the same place counts as distribution of the source\ncode, even though third parties are not compelled to copy the source\nalong with the object code.\n\n4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt otherwise\nto copy, modify, sublicense or distribute the Program is void, and will\nautomatically terminate your rights under this License. However, parties\nwho have received copies, or rights, from you under this License will\nnot have their licenses terminated so long as such parties remain in\nfull compliance.\n\n5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and all\nits terms and conditions for copying, distributing or modifying the\nProgram or works based on it.\n\n6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further restrictions\non the recipients' exercise of the rights granted herein. You are not\nresponsible for enforcing compliance by third parties to this License.\n\n7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot distribute\nso as to satisfy simultaneously your obligations under this License and\nany other pertinent obligations, then as a consequence you may not\ndistribute the Program at all. For example, if a patent license would\nnot permit royalty-free redistribution of the Program by all those who\nreceive copies directly or indirectly through you, then the only way you\ncould satisfy both it and this License would be to refrain entirely from\ndistribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is implemented\nby public license practices. Many people have made generous\ncontributions to the wide range of software distributed through that\nsystem in reliance on consistent application of that system; it is up to\nthe author/donor to decide if he or she is willing to distribute\nsoftware through any other system and a licensee cannot impose that choice.\n\nThis section is intended to make thoroughly clear what is believed to be\na consequence of the rest of this License.\n\n8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License may\nadd an explicit geographical distribution limitation excluding those\ncountries, so that distribution is permitted only in or among countries\nnot thus excluded. In such case, this License incorporates the\nlimitation as if written in the body of this License.\n\n9. The Free Software Foundation may publish revised and/or new\nversions of the General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Program does not specify a version\nnumber of this License, you may choose any version ever published by the\nFree Software Foundation.\n\n10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the\nauthor to ask for permission. For software which is copyrighted by the\nFree Software Foundation, write to the Free Software Foundation; we\nsometimes make exceptions for this. Our decision will be guided by the\ntwo goals of preserving the free status of all derivatives of our free\nsoftware and of promoting the sharing and reuse of software generally.\n\nNO WARRANTY\n\n11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND,\nEITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE\nENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH\nYOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL\nNECESSARY SERVICING, REPAIR OR CORRECTION.\n\n12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR\nDAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL\nDAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM\n(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED\nINACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF\nTHE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR\nOTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nEND OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to\nattach them to the start of each source file to most effectively convey\nthe exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n One line to give the program's name and a brief idea of what it does.\n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this\nwhen it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type\n `show w'. This is free software, and you are welcome to redistribute\n it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the\nappropriate parts of the General Public License. Of course, the commands\nyou use may be called something other than `show w' and `show c'; they\ncould even be mouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the program, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n program `Gnomovision' (which makes passes at compilers) written by\n James Hacker.\n\n signature of Ty Coon, 1 April 1989\n Ty Coon, President of Vice\n\nThis General Public License does not permit incorporating your program\ninto proprietary programs. If your program is a subroutine library, you\nmay consider it more useful to permit linking proprietary applications\nwith the library. If this is what you want to do, use the GNU Library\nGeneral Public License instead of this License.\n\n#\n\nCertain source files distributed by Oracle America, Inc. and/or its\naffiliates are subject to the following clarification and special\nexception to the GPLv2, based on the GNU Project exception for its\nClasspath libraries, known as the GNU Classpath Exception, but only\nwhere Oracle has expressly included in the particular source file's\nheader the words \"Oracle designates this particular file as subject to\nthe \"Classpath\" exception as provided by Oracle in the LICENSE file\nthat accompanied this code.\"\n\nYou should also note that Oracle includes multiple, independent\nprograms in this software package. Some of those programs are provided\nunder licenses deemed incompatible with the GPLv2 by the Free Software\nFoundation and others. For example, the package includes programs\nlicensed under the Apache License, Version 2.0. Such programs are\nlicensed to you under their original licenses.\n\nOracle facilitates your further distribution of this package by adding\nthe Classpath Exception to the necessary parts of its GPLv2 code, which\npermits you to use that code in combination with other independent\nmodules not licensed under the GPLv2. However, note that this would\nnot permit you to commingle code under an incompatible license with\nOracle's GPLv2 licensed code by, for example, cutting and pasting such\ncode into a file also containing Oracle's GPLv2 licensed code and then\ndistributing the result. Additionally, if you were to remove the\nClasspath Exception from any of the files to which it applies and\ndistribute the result, you would likely be required to license some or\nall of the other code in that distribution under the GPLv2 as well, and\nsince the GPLv2 is incompatible with the license terms of some items\nincluded in the distribution by Oracle, removing the Classpath\nException could therefore effectively compromise your ability to\nfurther distribute the package.\n\nProceed with caution and we recommend that you obtain the advice of a\nlawyer skilled in open source matters before removing the Classpath\nException or making modifications to this package which may\nsubsequently be redistributed and/or involve the use of third party\nsoftware.\n\nCLASSPATH EXCEPTION\nLinking this library statically or dynamically with other modules is\nmaking a combined work based on this library. Thus, the terms and\nconditions of the GNU General Public License version 2 cover the whole\ncombination.\n\nAs a special exception, the copyright holders of this library give you\npermission to link this library with independent modules to produce an\nexecutable, regardless of the license terms of these independent\nmodules, and to copy and distribute the resulting executable under\nterms of your choice, provided that you also meet, for each linked\nindependent module, the terms and conditions of the license of that\nmodule. An independent module is a module which is not derived from or\nbased on this library. If you modify this library, you may extend this\nexception to your version of the library, but you are not obligated to\ndo so. If you do not wish to do so, delete this exception statement\nfrom your version.", + "hash": "e1692074a62fa0fd6ef3ef00ec4904f0" + }, + "fea9e903303ed8cbc7854c24956a8913": { + "name": "Other", + "url": "https://raw.githubusercontent.com/JetBrains/intellij-community/master/LICENSE.txt", + "content": "JETBRAINS OPEN-SOURCE BUILD TERMS\n\nVersion 1.3, effective as of June 15, 2026\n\nIMPORTANT! READ CAREFULLY:\n\nTHESE TERMS APPLY TO THE OPEN-SOURCE BUILDS OF THE JETBRAINS INTEGRATED DEVELOPMENT ENVIRONMENT TOOLS\nCALLED \u2018INTELLIJ IDEA\u2019 AND \u2018PYCHARM\u2019 (SUCH TOOLS, \u201cOPEN-SOURCE BUILD\u201d PRODUCTS) WHICH CONSIST OF OPEN SOURCE SOFTWARE\nSUBJECT TO THE APACHE 2.0 LICENSE (AVAILABLE HERE: https://www.apache.org/licenses/LICENSE-2.0).\n\n\"JetBrains\" or \"we\" means JetBrains s.r.o., with its principal place of business\nat Na Hrebenech II 1718/8, Prague, 14000, Czech Republic, registered in the Commercial Register\nmaintained by the Municipal Court of Prague, Section C, File 86211, ID No.: 265 02 275.\n\n\"You\" means any Organization or natural person using an Open-Source Build product in accordance with these terms,\nwhere \u201cOrganization\u201d includes any corporation, company, partnership, association, or other entity that controls,\nis controlled by, or is under common control with you. For the purposes of this definition, \u201ccontrol\u201d means\n(i) the power, directly or indirectly, to direct or manage such entity, whether by contract or otherwise, or\n(ii) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\nPersonal Data \u2014 In connection with your use of Open-Source Build products, we and our associated companies will\nprocess your personal data, including but not limited to your contact and identification details, and data about\nyour usage of our software and services, in order to (i) provide you with software, services, or information;\n(ii) protect us from piracy and unlawful use of our software or services; (iii) improve our offerings based on usage;\n(iv) create and maintain our internal records and to protect our rights and interests and those of other users;\n(v) promote and market our software and services; and\n(vi) to fulfil legal duties stipulated by accounting, taxation, and other laws. You may object to the processing\nof your personal data for the purposes of (i) through (v) at any time. More detailed information can be found in\nour Privacy Notice, available here: https://www.jetbrains.com/legal/docs/privacy/privacy.html.\n\nPersonal Data Collected \u2014 For the above purposes, we may collect, among other things, your IP address,\nJetBrains Account username, JetBrains Account password, first name, last name, and email address.\n\nAnonymous Data \u2014 On installation and execution, the Open-Source Build product may send us certain information,\nwhich will not contain any personal data, including product version, product edition, and information about\nthe operating system where the Open-Source Build product is installed. A unique ID, which\ndoes not contain any personal data, is also used to distinguish instances. The Open-Source Build product\ncan check for available updates, as well as available updates for plugins or components.\nIn addition, you can opt in to further anonymous data processing. If you do so, the Open-Source Build product\nmay electronically send anonymous information to us related to your usage of the product features.\nThis further information may include, but is not limited to, frameworks, file templates being used in the IDEs,\nactions invoked, and other interactions with product features. This information will not contain your source code,\nyour personal data, information about your JetBrains Account, or subscription information.\n\nAccidentally Sent Information \u2014 We are not responsible for any processing of personal data you accidentally send to us.\n\nFeedback \u2014 You have no obligation to provide us with ideas, guidance, suggestions, proposals, or bug reports (\u201cFeedback\u201d).\nHowever, if you submit Feedback to us, then you grant us a non-exclusive, worldwide, royalty-free license that is\nsub-licensable and transferable, to make, use, sell, have made, offer to sell, import, reproduce, publicly display,\ndistribute, modify, or publicly perform the Feedback in any manner without any obligation, royalty, or restriction\nbased on intellectual property rights or otherwise.\n\nThird Party Software \u2014 Open-Source Build includes code and libraries licensed to us by third parties, including\nopen source software (\u201cThird-Party Software\u201d). A list of Third-Party Software included in each Open-Source Build product\nis available in the product documentation. All Third-Party Software is provided to you under the respective terms\nstipulated in the Open-Source Build product documentation.\n\nDISCLAIMER OF DAMAGES AND EXCLUSION OF LIABILITY \u2014 ALL OPEN-SOURCE BUILD PRODUCTS (INCLUDING THIRD-PARTY SOFTWARE)\nARE PROVIDED TO YOU ON AN \u201cAS IS\u201d AND \u201cAS AVAILABLE\u201d BASIS. USE OF THE OPEN-SOURCE BUILD PRODUCTS IS AT YOUR OWN RISK\nAND WITHOUT WARRANTIES, EXPRESS OR IMPLIED (TO THE MAXIMUM EXTENT PERMITTED BY LAW). FURTHER DETAILS MAY BE FOUND\nIN THE APPLICABLE OPEN-SOURCE BUILD TERMS OR THIRD-PARTY SOFTWARE TERMS. IN NO EVENT WILL WE BE LIABLE TO YOU\nOR ANYONE ELSE FOR ANY LOSS OF USE, DATA, GOODWILL, OR PROFITS, WHETHER OR NOT FORESEEABLE, OR ANY SPECIAL,\nINCIDENTAL, INDIRECT, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES OR LOSSES WHATSOEVER INCURRED IN CONNECTION\nWITH YOUR USAGE OF ANY OPEN-SOURCE BUILD PRODUCT. THIS LIMITATION WILL APPLY EVEN IF THE JETBRAINS PARTIES\nHAVE BEEN ADVISED OF THE POSSIBILITY OF LIABILITY.\n\nExport Compliance \u2014 You must comply with all applicable laws and regulations with regard to economic sanctions,\nexport controls, import regulations, restrictive measures, and trade embargoes, including those of the European Union\nand the United States of America.\n\nReservation of Rights \u2014 We reserve the right at any time to cease provision of or alter features, specifications,\ncapabilities, functions, terms of use (including this document), release dates, general availability,\nor other characteristics of Open-Source Build products.\n\nGoverning Law \u2014 These terms are governed by the laws of the Czech Republic, without reference to conflict of laws principles,\nand specifically excluding the United Nations Convention on Contracts for the International Sale of Goods.\nThe parties to this Agreement undertake to use the best commercial efforts to amicably settle any disputes\narising hereunder (\u201cDispute\u201d). Should the parties to this Agreement fail to settle a Dispute amicably, the Dispute\nwill be excluded from the jurisdiction of general courts and all such Disputes will be finally decided\nby the Arbitration Court attached to the Czech Chamber of Commerce and the Agricultural Chamber of the Czech Republic\nby three arbitrators in accordance with the Rules of that Arbitration Court, and the language of the proceedings\nwill be English; provided that if you are a consumer, you and JetBrains agree that any Dispute-related litigation\nmay only be brought in, and shall be subject to the jurisdiction of, any competent court of the Czech Republic,\nunless provided otherwise by applicable consumer law.\nConsumer Disputes can also be settled out of court through the Czech Trade Inspection Authority (www.coi.cz)\nor the European Commission online platform for dispute resolution (ec.europa.eu/consumers/odr).\n\nOpportunity to review \u2014 You declare that you have had sufficient opportunity to review these terms,\nunderstand the content of all of its clauses, negotiate its terms, and seek independent professional legal advice\nin that respect before entering into it. Consequently, any statutory \u201cform contract\u201d (\u201cadhesion contract\u201d) regulations\nshall not be applicable to these terms.", + "hash": "fea9e903303ed8cbc7854c24956a8913" } } } \ No newline at end of file diff --git a/app-test/files/wasmJs/aboutlibraries.json b/app-test/files/wasmJs/aboutlibraries.json index c6db724b8..68697ae39 100644 --- a/app-test/files/wasmJs/aboutlibraries.json +++ b/app-test/files/wasmJs/aboutlibraries.json @@ -2,61 +2,67 @@ "libraries": [ { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", - "funding": [ - - ], + "artifactVersion": "2.4.10", + "name": "Kotlin Stdlib", + "description": "Kotlin Standard Library", + "website": "https://kotlinlang.org/", "developers": [ { - "organisationUrl": "https://www.jetbrains.com", - "name": "Kotlin Team" + "name": "Kotlin Team", + "organisationUrl": "https://www.jetbrains.com" } ], - "artifactVersion": "2.1.21", - "description": "Kotlin Standard Library", "scm": { "connection": "scm:git:https://github.com/JetBrains/kotlin.git", - "url": "https://github.com/JetBrains/kotlin", - "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git" + "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git", + "url": "https://github.com/JetBrains/kotlin" }, - "name": "Kotlin Stdlib", - "website": "https://kotlinlang.org/", "licenses": [ "Apache-2.0" + ], + "funding": [ + + ], + "targets": [ + "wasmJs" ] }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-wasm-js", - "funding": [ - - ], + "artifactVersion": "2.4.10", + "name": "Kotlin Stdlib Wasm Js", + "description": "Kotlin Standard Library for experimental WebAssembly JS platform", + "website": "https://kotlinlang.org/", "developers": [ { - "organisationUrl": "https://www.jetbrains.com", - "name": "Kotlin Team" + "name": "Kotlin Team", + "organisationUrl": "https://www.jetbrains.com" } ], - "artifactVersion": "2.1.21", - "description": "Kotlin Standard Library for experimental WebAssembly JS platform", "scm": { "connection": "scm:git:https://github.com/JetBrains/kotlin.git", - "url": "https://github.com/JetBrains/kotlin", - "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git" + "developerConnection": "scm:git:https://github.com/JetBrains/kotlin.git", + "url": "https://github.com/JetBrains/kotlin" }, - "name": "Kotlin Stdlib Wasm Js", - "website": "https://kotlinlang.org/", "licenses": [ "Apache-2.0" + ], + "funding": [ + + ], + "targets": [ + "wasmJs" ] } ], "licenses": { "Apache-2.0": { + "name": "Apache License 2.0", + "url": "https://spdx.org/licenses/Apache-2.0.html", "content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\nTo apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.", - "hash": "Apache-2.0", "internalHash": "Apache-2.0", - "url": "https://spdx.org/licenses/Apache-2.0.html", "spdxId": "Apache-2.0", - "name": "Apache License 2.0" + "hash": "Apache-2.0" } } } \ No newline at end of file diff --git a/sample/desktop/src/commonMain/composeResources/files/aboutlibraries.json b/sample/desktop/src/commonMain/composeResources/files/aboutlibraries.json index 151f10780..4f65a846a 100644 --- a/sample/desktop/src/commonMain/composeResources/files/aboutlibraries.json +++ b/sample/desktop/src/commonMain/composeResources/files/aboutlibraries.json @@ -1,7 +1,7 @@ { "libraries": [ { - "uniqueId": "androidx.annotation:annotation-jvm", + "uniqueId": "androidx.annotation:annotation", "artifactVersion": "1.9.1", "name": "Annotation", "description": "Provides source annotations for tooling and readability.", @@ -48,7 +48,7 @@ ] }, { - "uniqueId": "androidx.collection:collection-jvm", + "uniqueId": "androidx.collection:collection", "artifactVersion": "1.5.0", "name": "collections", "description": "Standalone efficient collections.", @@ -73,10 +73,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-annotation-jvm", + "uniqueId": "androidx.compose.runtime:runtime", "artifactVersion": "1.11.2", - "name": "Compose Runtime Annotation", - "description": "Provides Compose-specific annotations used by the compiler and tooling", + "name": "Compose Runtime", + "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -98,10 +98,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-desktop", + "uniqueId": "androidx.compose.runtime:runtime-annotation", "artifactVersion": "1.11.2", - "name": "Compose Runtime", - "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", + "name": "Compose Runtime Annotation", + "description": "Provides Compose-specific annotations used by the compiler and tooling", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -123,7 +123,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-retain-desktop", + "uniqueId": "androidx.compose.runtime:runtime-retain", "artifactVersion": "1.11.2", "name": "Compose Runtime Retain", "description": "Preserve state in composable methods across configuration changes and other transient content destruction scenarios", @@ -148,7 +148,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-saveable-desktop", + "uniqueId": "androidx.compose.runtime:runtime-saveable", "artifactVersion": "1.11.2", "name": "Compose Saveable", "description": "Compose components that allow saving and restoring the local ui state", @@ -173,7 +173,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-common-jvm", + "uniqueId": "androidx.lifecycle:lifecycle-common", "artifactVersion": "2.9.4", "name": "Lifecycle-Common", "description": "Android Lifecycle-Common", @@ -198,10 +198,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose-desktop", + "uniqueId": "androidx.lifecycle:lifecycle-runtime", "artifactVersion": "2.9.4", - "name": "Lifecycle Runtime Compose", - "description": "Compose integration with Lifecycle", + "name": "Lifecycle Runtime", + "description": "Android Lifecycle Runtime", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -223,10 +223,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-desktop", + "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose", "artifactVersion": "2.9.4", - "name": "Lifecycle Runtime", - "description": "Android Lifecycle Runtime", + "name": "Lifecycle Runtime Compose", + "description": "Compose integration with Lifecycle", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -248,7 +248,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-desktop", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel", "artifactVersion": "2.9.4", "name": "Lifecycle ViewModel", "description": "Android Lifecycle ViewModel", @@ -273,7 +273,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate-desktop", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate", "artifactVersion": "2.9.4", "name": "Lifecycle ViewModel with SavedState", "description": "Android Lifecycle ViewModel", @@ -298,7 +298,7 @@ ] }, { - "uniqueId": "androidx.navigationevent:navigationevent-desktop", + "uniqueId": "androidx.navigationevent:navigationevent", "artifactVersion": "1.0.1", "name": "Navigation Event", "description": "Provides APIs to easily intercept platform navigation events, including swipes and clicks, to provide a consistent API surface for handling these events.", @@ -323,10 +323,10 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-compose-desktop", + "uniqueId": "androidx.savedstate:savedstate", "artifactVersion": "1.4.0", - "name": "Saved State Compose", - "description": "Compose integration with Saved State", + "name": "Saved State", + "description": "Android Lifecycle Saved State", "website": "https://developer.android.com/jetpack/androidx/releases/savedstate#1.4.0", "developers": [ { @@ -348,10 +348,10 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-desktop", + "uniqueId": "androidx.savedstate:savedstate-compose", "artifactVersion": "1.4.0", - "name": "Saved State", - "description": "Android Lifecycle Saved State", + "name": "Saved State Compose", + "description": "Compose integration with Saved State", "website": "https://developer.android.com/jetpack/androidx/releases/savedstate#1.4.0", "developers": [ { @@ -372,29 +372,6 @@ ] }, - { - "uniqueId": "com.github.skydoves:compose-stability-runtime-jvm", - "artifactVersion": "0.9.0", - "name": "Compose Stability Analyzer Runtime", - "description": "A Compose Compiler plugin that analyzes composable functions and generates stability reports.", - "website": "https://github.com/skydoves/compose-stability-analyzer/", - "developers": [ - { - "name": "Jaewoong Eum" - } - ], - "scm": { - "connection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "developerConnection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "url": "https://github.com/skydoves/compose-stability-analyzer/" - }, - "licenses": [ - "Apache-2.0" - ], - "funding": [ - - ] - }, { "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-common", "artifactVersion": "2.9.6", @@ -444,7 +421,7 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime-compose-desktop", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime-compose", "artifactVersion": "2.9.6", "name": "Lifecycle Runtime Compose", "description": "Compose integration with Lifecycle", @@ -540,7 +517,7 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.savedstate:savedstate-compose-desktop", + "uniqueId": "org.jetbrains.androidx.savedstate:savedstate-compose", "artifactVersion": "1.3.6", "name": "Saved State Compose", "description": "Compose integration with Saved State", @@ -564,10 +541,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.animation:animation-core-desktop", + "uniqueId": "org.jetbrains.compose.animation:animation", "artifactVersion": "1.11.1", - "name": "Compose Animation Core", - "description": "Animation engine and animation primitives that are the building blocks of the Compose animation library", + "name": "Compose Animation", + "description": "Compose animation library", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -588,10 +565,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.animation:animation-desktop", + "uniqueId": "org.jetbrains.compose.animation:animation-core", "artifactVersion": "1.11.1", - "name": "Compose Animation", - "description": "Compose animation library", + "name": "Compose Animation Core", + "description": "Animation engine and animation primitives that are the building blocks of the Compose animation library", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -660,7 +637,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.components:components-resources-desktop", + "uniqueId": "org.jetbrains.compose.components:components-resources", "artifactVersion": "1.11.1", "name": "Resources for Compose JB", "description": "Resources for Compose JB", @@ -683,6 +660,30 @@ ] }, + { + "uniqueId": "org.jetbrains.compose.desktop:desktop", + "artifactVersion": "1.11.1", + "name": "Compose Desktop", + "description": "Compose Desktop", + "website": "https://github.com/JetBrains/compose-multiplatform", + "developers": [ + { + "name": "Compose Multiplatform Team", + "organisationUrl": "https://www.jetbrains.com" + } + ], + "scm": { + "connection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "developerConnection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "url": "https://github.com/JetBrains/compose-multiplatform" + }, + "licenses": [ + "Apache-2.0" + ], + "funding": [ + + ] + }, { "uniqueId": "org.jetbrains.compose.desktop:desktop-jvm-macos-arm64", "artifactVersion": "1.11.1", @@ -708,7 +709,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.foundation:foundation-desktop", + "uniqueId": "org.jetbrains.compose.foundation:foundation", "artifactVersion": "1.11.1", "name": "Compose Foundation", "description": "Higher level abstractions of the Compose UI primitives. This library is design system agnostic, providing the high-level building blocks for both application and design-system developers", @@ -732,7 +733,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.foundation:foundation-layout-desktop", + "uniqueId": "org.jetbrains.compose.foundation:foundation-layout", "artifactVersion": "1.11.1", "name": "Compose Layouts", "description": "Compose layout implementations", @@ -756,7 +757,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material3:material3-desktop", + "uniqueId": "org.jetbrains.compose.material3:material3", "artifactVersion": "1.9.0", "name": "Compose Material3 Components", "description": "Compose Material You Design Components library", @@ -780,7 +781,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-desktop", + "uniqueId": "org.jetbrains.compose.material:material", "artifactVersion": "1.11.1", "name": "Compose Material Components", "description": "Compose Material Design Components library", @@ -804,7 +805,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-icons-core-desktop", + "uniqueId": "org.jetbrains.compose.material:material-icons-core", "artifactVersion": "1.7.3", "name": "Compose Material Icons Core", "description": "Compose Material Design core icons. This module contains the most commonly used set of Material icons.", @@ -828,7 +829,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-icons-extended-desktop", + "uniqueId": "org.jetbrains.compose.material:material-icons-extended", "artifactVersion": "1.7.3", "name": "Compose Material Icons Extended", "description": "Compose Material Design extended icons. This module contains all Material icons. It is a very large dependency and should not be included directly.", @@ -852,7 +853,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-ripple-desktop", + "uniqueId": "org.jetbrains.compose.material:material-ripple", "artifactVersion": "1.11.1", "name": "Compose Material Ripple", "description": "Material ripple used to build interactive components", @@ -876,7 +877,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.runtime:runtime-desktop", + "uniqueId": "org.jetbrains.compose.runtime:runtime", "artifactVersion": "1.11.1", "name": "Compose Runtime", "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", @@ -900,7 +901,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.runtime:runtime-saveable-desktop", + "uniqueId": "org.jetbrains.compose.runtime:runtime-saveable", "artifactVersion": "1.11.1", "name": "Compose Saveable", "description": "Compose components that allow saving and restoring the local ui state", @@ -924,10 +925,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-backhandler-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui", "artifactVersion": "1.11.1", - "name": "Compose BackHandler", - "description": "Provides BackHandler in Compose Multiplatform projects", + "name": "Compose UI", + "description": "Compose UI primitives. This library contains the primitives that form the Compose UI Toolkit, such as drawing, measurement and layout.", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -948,10 +949,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-backhandler", "artifactVersion": "1.11.1", - "name": "Compose UI", - "description": "Compose UI primitives. This library contains the primitives that form the Compose UI Toolkit, such as drawing, measurement and layout.", + "name": "Compose BackHandler", + "description": "Provides BackHandler in Compose Multiplatform projects", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -972,7 +973,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-geometry-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-geometry", "artifactVersion": "1.11.1", "name": "Compose Geometry", "description": "Compose classes related to dimensions without units", @@ -996,7 +997,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-graphics-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-graphics", "artifactVersion": "1.11.1", "name": "Compose Graphics", "description": "Compose graphics", @@ -1020,7 +1021,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-text-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-text", "artifactVersion": "1.11.1", "name": "Compose UI Text", "description": "Compose Text primitives and utilities", @@ -1044,7 +1045,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-tooling-preview-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-tooling-preview", "artifactVersion": "1.11.1", "name": "Compose UI Preview Tooling", "description": "Compose tooling library API. This library provides the API required to declare @Preview composables in user apps.", @@ -1068,7 +1069,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-unit-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-unit", "artifactVersion": "1.11.1", "name": "Compose Unit", "description": "Compose classes for simple units", @@ -1092,7 +1093,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-util-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-util", "artifactVersion": "1.11.1", "name": "Compose Util", "description": "Internal Compose utilities used by other modules", @@ -1117,7 +1118,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib", "description": "Kotlin Standard Library", "website": "https://kotlinlang.org/", @@ -1141,7 +1142,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-common", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib Common", "description": "Kotlin Common Standard Library (legacy, use kotlin-stdlib instead)", "website": "https://kotlinlang.org/", @@ -1164,7 +1165,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:atomicfu-jvm", + "uniqueId": "org.jetbrains.kotlinx:atomicfu", "artifactVersion": "0.28.0", "name": "atomicfu", "description": "AtomicFU utilities", @@ -1208,7 +1209,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core", "artifactVersion": "1.9.0", "name": "kotlinx-coroutines-core", "description": "Coroutines support libraries for Kotlin", @@ -1230,7 +1231,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime", "artifactVersion": "0.7.1", "name": "kotlinx-datetime", "description": "Kotlin Datetime Library", @@ -1253,7 +1254,7 @@ }, { "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-bom", - "artifactVersion": "1.7.3", + "artifactVersion": "1.11.0", "name": "kotlinx-serialization-bom", "description": "Kotlin multiplatform serialization runtime library", "website": "https://github.com/Kotlin/kotlinx.serialization", @@ -1274,8 +1275,8 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core-jvm", - "artifactVersion": "1.7.3", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core", + "artifactVersion": "1.11.0", "name": "kotlinx-serialization-core", "description": "Kotlin multiplatform serialization runtime library", "website": "https://github.com/Kotlin/kotlinx.serialization", @@ -1296,7 +1297,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json", "artifactVersion": "1.11.0", "name": "kotlinx-serialization-json", "description": "Kotlin multiplatform serialization runtime library", diff --git a/sample/shared/src/commonMain/composeResources/files/aboutlibraries.json b/sample/shared/src/commonMain/composeResources/files/aboutlibraries.json index 82c354066..e15a5d384 100644 --- a/sample/shared/src/commonMain/composeResources/files/aboutlibraries.json +++ b/sample/shared/src/commonMain/composeResources/files/aboutlibraries.json @@ -76,11 +76,11 @@ ] }, { - "uniqueId": "androidx.annotation:annotation-experimental", - "artifactVersion": "1.4.1", - "name": "Experimental annotation", - "description": "Java annotation for use on unstable Android API surfaces. When used in conjunction with the Experimental annotation lint checks, this annotation provides functional parity with Kotlin's Experimental annotation.", - "website": "https://developer.android.com/jetpack/androidx/releases/annotation#1.4.1", + "uniqueId": "androidx.annotation:annotation", + "artifactVersion": "1.10.0", + "name": "Annotation", + "description": "Provides source annotations for tooling and readability.", + "website": "https://developer.android.com/jetpack/androidx/releases/annotation#1.10.0", "developers": [ { "name": "The Android Open Source Project" @@ -101,11 +101,11 @@ ] }, { - "uniqueId": "androidx.annotation:annotation-jvm", - "artifactVersion": "1.9.1", - "name": "Annotation", - "description": "Provides source annotations for tooling and readability.", - "website": "https://developer.android.com/jetpack/androidx/releases/annotation#1.9.1", + "uniqueId": "androidx.annotation:annotation-experimental", + "artifactVersion": "1.4.1", + "name": "Experimental annotation", + "description": "Java annotation for use on unstable Android API surfaces. When used in conjunction with the Experimental annotation lint checks, this annotation provides functional parity with Kotlin's Experimental annotation.", + "website": "https://developer.android.com/jetpack/androidx/releases/annotation#1.4.1", "developers": [ { "name": "The Android Open Source Project" @@ -192,7 +192,7 @@ ] }, { - "uniqueId": "androidx.collection:collection-jvm", + "uniqueId": "androidx.collection:collection", "artifactVersion": "1.5.0", "name": "collections", "description": "Standalone efficient collections.", @@ -242,7 +242,7 @@ ] }, { - "uniqueId": "androidx.compose.animation:animation-android", + "uniqueId": "androidx.compose.animation:animation", "artifactVersion": "1.11.2", "name": "Compose Animation", "description": "Compose animation library", @@ -267,7 +267,7 @@ ] }, { - "uniqueId": "androidx.compose.animation:animation-core-android", + "uniqueId": "androidx.compose.animation:animation-core", "artifactVersion": "1.11.2", "name": "Compose Animation Core", "description": "Animation engine and animation primitives that are the building blocks of the Compose animation library", @@ -292,7 +292,7 @@ ] }, { - "uniqueId": "androidx.compose.foundation:foundation-android", + "uniqueId": "androidx.compose.foundation:foundation", "artifactVersion": "1.11.2", "name": "Compose Foundation", "description": "Higher level abstractions of the Compose UI primitives. This library is design system agnostic, providing the high-level building blocks for both application and design-system developers", @@ -317,7 +317,7 @@ ] }, { - "uniqueId": "androidx.compose.foundation:foundation-layout-android", + "uniqueId": "androidx.compose.foundation:foundation-layout", "artifactVersion": "1.11.2", "name": "Compose Layouts", "description": "Compose layout implementations", @@ -342,7 +342,7 @@ ] }, { - "uniqueId": "androidx.compose.material3:material3-android", + "uniqueId": "androidx.compose.material3:material3", "artifactVersion": "1.4.0", "name": "Compose Material3 Components", "description": "Compose Material You Design Components library", @@ -367,7 +367,7 @@ ] }, { - "uniqueId": "androidx.compose.material:material-android", + "uniqueId": "androidx.compose.material:material", "artifactVersion": "1.11.2", "name": "Compose Material Components", "description": "Compose Material Design Components library", @@ -392,7 +392,7 @@ ] }, { - "uniqueId": "androidx.compose.material:material-icons-core-android", + "uniqueId": "androidx.compose.material:material-icons-core", "artifactVersion": "1.7.6", "name": "Compose Material Icons Core", "description": "Compose Material Design core icons. This module contains the most commonly used set of Material icons.", @@ -417,7 +417,7 @@ ] }, { - "uniqueId": "androidx.compose.material:material-icons-extended-android", + "uniqueId": "androidx.compose.material:material-icons-extended", "artifactVersion": "1.7.6", "name": "Compose Material Icons Extended", "description": "Compose Material Design extended icons. This module contains all Material icons. It is a very large dependency and should not be included directly.", @@ -442,7 +442,7 @@ ] }, { - "uniqueId": "androidx.compose.material:material-ripple-android", + "uniqueId": "androidx.compose.material:material-ripple", "artifactVersion": "1.11.2", "name": "Compose Material Ripple", "description": "Material ripple used to build interactive components", @@ -467,7 +467,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-android", + "uniqueId": "androidx.compose.runtime:runtime", "artifactVersion": "1.11.2", "name": "Compose Runtime", "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", @@ -492,7 +492,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-annotation-android", + "uniqueId": "androidx.compose.runtime:runtime-annotation", "artifactVersion": "1.11.2", "name": "Compose Runtime Annotation", "description": "Provides Compose-specific annotations used by the compiler and tooling", @@ -517,7 +517,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-retain-android", + "uniqueId": "androidx.compose.runtime:runtime-retain", "artifactVersion": "1.11.2", "name": "Compose Runtime Retain", "description": "Preserve state in composable methods across configuration changes and other transient content destruction scenarios", @@ -542,7 +542,7 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-saveable-android", + "uniqueId": "androidx.compose.runtime:runtime-saveable", "artifactVersion": "1.11.2", "name": "Compose Saveable", "description": "Compose components that allow saving and restoring the local ui state", @@ -567,7 +567,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-android", + "uniqueId": "androidx.compose.ui:ui", "artifactVersion": "1.11.2", "name": "Compose UI", "description": "Compose UI primitives. This library contains the primitives that form the Compose UI Toolkit, such as drawing, measurement and layout.", @@ -592,7 +592,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-geometry-android", + "uniqueId": "androidx.compose.ui:ui-geometry", "artifactVersion": "1.11.2", "name": "Compose Geometry", "description": "Compose classes related to dimensions without units", @@ -617,7 +617,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-graphics-android", + "uniqueId": "androidx.compose.ui:ui-graphics", "artifactVersion": "1.11.2", "name": "Compose Graphics", "description": "Compose graphics", @@ -642,7 +642,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-text-android", + "uniqueId": "androidx.compose.ui:ui-text", "artifactVersion": "1.11.2", "name": "Compose UI Text", "description": "Compose Text primitives and utilities", @@ -667,7 +667,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-tooling-preview-android", + "uniqueId": "androidx.compose.ui:ui-tooling-preview", "artifactVersion": "1.11.2", "name": "Compose UI Preview Tooling", "description": "Compose tooling library API. This library provides the API required to declare @Preview composables in user apps.", @@ -692,7 +692,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-unit-android", + "uniqueId": "androidx.compose.ui:ui-unit", "artifactVersion": "1.11.2", "name": "Compose Unit", "description": "Compose classes for simple units", @@ -717,7 +717,7 @@ ] }, { - "uniqueId": "androidx.compose.ui:ui-util-android", + "uniqueId": "androidx.compose.ui:ui-util", "artifactVersion": "1.11.2", "name": "Compose Util", "description": "Internal Compose utilities used by other modules", @@ -765,10 +765,10 @@ }, { "uniqueId": "androidx.core:core", - "artifactVersion": "1.18.0", + "artifactVersion": "1.19.0", "name": "Core", "description": "Provides backward-compatible implementations of Android platform APIs and features.", - "website": "https://developer.android.com/jetpack/androidx/releases/core#1.18.0", + "website": "https://developer.android.com/jetpack/androidx/releases/core#1.19.0", "developers": [ { "name": "The Android Open Source Project" @@ -790,10 +790,10 @@ }, { "uniqueId": "androidx.core:core-ktx", - "artifactVersion": "1.18.0", + "artifactVersion": "1.19.0", "name": "Core Kotlin Extensions", "description": "Kotlin extensions for 'core' artifact", - "website": "https://developer.android.com/jetpack/androidx/releases/core#1.18.0", + "website": "https://developer.android.com/jetpack/androidx/releases/core#1.19.0", "developers": [ { "name": "The Android Open Source Project" @@ -996,10 +996,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-common-java8", + "uniqueId": "androidx.lifecycle:lifecycle-common", "artifactVersion": "2.9.4", - "name": "Lifecycle-Common for Java 8", - "description": "Android Lifecycle-Common for Java 8 Language", + "name": "Lifecycle-Common", + "description": "Android Lifecycle-Common", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -1021,10 +1021,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-common-jvm", + "uniqueId": "androidx.lifecycle:lifecycle-common-java8", "artifactVersion": "2.9.4", - "name": "Lifecycle-Common", - "description": "Android Lifecycle-Common", + "name": "Lifecycle-Common for Java 8", + "description": "Android Lifecycle-Common for Java 8 Language", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -1146,7 +1146,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-android", + "uniqueId": "androidx.lifecycle:lifecycle-runtime", "artifactVersion": "2.9.4", "name": "Lifecycle Runtime", "description": "Android Lifecycle Runtime", @@ -1171,7 +1171,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose-android", + "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose", "artifactVersion": "2.9.4", "name": "Lifecycle Runtime Compose", "description": "Compose integration with Lifecycle", @@ -1196,7 +1196,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-ktx-android", + "uniqueId": "androidx.lifecycle:lifecycle-runtime-ktx", "artifactVersion": "2.9.4", "name": "Lifecycle Kotlin Extensions", "description": "Kotlin extensions for 'lifecycle' artifact", @@ -1221,7 +1221,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-android", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel", "artifactVersion": "2.9.4", "name": "Lifecycle ViewModel", "description": "Android Lifecycle ViewModel", @@ -1271,7 +1271,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate-android", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate", "artifactVersion": "2.9.4", "name": "Lifecycle ViewModel with SavedState", "description": "Android Lifecycle ViewModel", @@ -1340,7 +1340,7 @@ ] }, { - "uniqueId": "androidx.navigationevent:navigationevent-desktop", + "uniqueId": "androidx.navigationevent:navigationevent", "artifactVersion": "1.0.1", "name": "Navigation Event", "description": "Provides APIs to easily intercept platform navigation events, including swipes and clicks, to provide a consistent API surface for handling these events.", @@ -1412,7 +1412,7 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-android", + "uniqueId": "androidx.savedstate:savedstate", "artifactVersion": "1.4.0", "name": "Saved State", "description": "Android Lifecycle Saved State", @@ -1437,7 +1437,7 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-compose-android", + "uniqueId": "androidx.savedstate:savedstate-compose", "artifactVersion": "1.4.0", "name": "Saved State Compose", "description": "Compose integration with Saved State", @@ -1603,7 +1603,7 @@ ] }, { - "uniqueId": "androidx.window:window-core-android", + "uniqueId": "androidx.window:window-core", "artifactVersion": "1.5.0", "name": "WindowManager Core", "description": "WindowManager Core Library.", @@ -1627,29 +1627,6 @@ ] }, - { - "uniqueId": "com.github.skydoves:compose-stability-runtime-android", - "artifactVersion": "0.9.0", - "name": "Compose Stability Analyzer Runtime", - "description": "A Compose Compiler plugin that analyzes composable functions and generates stability reports.", - "website": "https://github.com/skydoves/compose-stability-analyzer/", - "developers": [ - { - "name": "Jaewoong Eum" - } - ], - "scm": { - "connection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "developerConnection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "url": "https://github.com/skydoves/compose-stability-analyzer/" - }, - "licenses": [ - "Apache-2.0" - ], - "funding": [ - - ] - }, { "uniqueId": "com.google.guava:listenablefuture", "artifactVersion": "1.0", @@ -1939,7 +1916,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.components:components-resources-android", + "uniqueId": "org.jetbrains.compose.components:components-resources", "artifactVersion": "1.11.1", "name": "Resources for Compose JB", "description": "Resources for Compose JB", @@ -1962,6 +1939,30 @@ ] }, + { + "uniqueId": "org.jetbrains.compose.desktop:desktop", + "artifactVersion": "1.11.1", + "name": "Compose Desktop", + "description": "Compose Desktop", + "website": "https://github.com/JetBrains/compose-multiplatform", + "developers": [ + { + "name": "Compose Multiplatform Team", + "organisationUrl": "https://www.jetbrains.com" + } + ], + "scm": { + "connection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "developerConnection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "url": "https://github.com/JetBrains/compose-multiplatform" + }, + "licenses": [ + "Apache-2.0" + ], + "funding": [ + + ] + }, { "uniqueId": "org.jetbrains.compose.desktop:desktop-jvm-macos-arm64", "artifactVersion": "1.11.1", @@ -2035,8 +2036,8 @@ ] }, { - "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-annotations-jvm", - "artifactVersion": "1.2.0-alpha01", + "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-annotations", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-annotations", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2058,7 +2059,7 @@ }, { "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-core", - "artifactVersion": "1.2.0-alpha01", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-core", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2080,7 +2081,7 @@ }, { "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-devtools-api", - "artifactVersion": "1.2.0-alpha01", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-devtools-api", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2102,7 +2103,7 @@ }, { "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-orchestration", - "artifactVersion": "1.2.0-alpha01", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-orchestration", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2123,8 +2124,8 @@ ] }, { - "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-runtime-api-jvm", - "artifactVersion": "1.2.0-alpha01", + "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-runtime-api", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-runtime-api", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2146,7 +2147,7 @@ }, { "uniqueId": "org.jetbrains.compose.hot-reload:hot-reload-runtime-jvm", - "artifactVersion": "1.2.0-alpha01", + "artifactVersion": "1.3.0-alpha01", "name": "hot-reload-runtime-jvm", "description": "Compose Hot Reload implementation", "website": "https://github.com/JetBrains/compose-hot-reload", @@ -2359,7 +2360,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-backhandler-android", + "uniqueId": "org.jetbrains.compose.ui:ui-backhandler", "artifactVersion": "1.9.1", "name": "Compose Multiplatform BackHandler", "description": "Provides BackHandler in Compose Multiplatform projects", @@ -2383,7 +2384,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-backhandler-desktop", + "uniqueId": "org.jetbrains.compose.ui:ui-backhandler-js", "artifactVersion": "1.11.1", "name": "Compose BackHandler", "description": "Provides BackHandler in Compose Multiplatform projects", @@ -2576,7 +2577,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-dom-api-compat", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Dom Api Compat", "description": "Kotlin DOM API compatibility library", "website": "https://kotlinlang.org/", @@ -2600,7 +2601,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib", "description": "Kotlin Standard Library", "website": "https://kotlinlang.org/", @@ -2624,7 +2625,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-common", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib Common", "description": "Kotlin Common Standard Library (legacy, use kotlin-stdlib instead)", "website": "https://kotlinlang.org/", @@ -2648,7 +2649,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-js", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib Js", "description": "Kotlin Standard Library for JS", "website": "https://kotlinlang.org/", @@ -2672,7 +2673,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-wasm-js", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib Wasm Js", "description": "Kotlin Standard Library for experimental WebAssembly JS platform", "website": "https://kotlinlang.org/", @@ -2719,7 +2720,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:atomicfu-jvm", + "uniqueId": "org.jetbrains.kotlinx:atomicfu", "artifactVersion": "0.28.0", "name": "atomicfu", "description": "AtomicFU utilities", @@ -2741,7 +2742,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-browser-js", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-browser", "artifactVersion": "0.5.0", "name": "kotlinx-browser", "description": "Kotlinx Browser", @@ -2807,7 +2808,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core", "artifactVersion": "1.9.0", "name": "kotlinx-coroutines-core", "description": "Coroutines support libraries for Kotlin", @@ -2829,7 +2830,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime", "artifactVersion": "0.7.1", "name": "kotlinx-datetime", "description": "Kotlin Datetime Library", @@ -2852,7 +2853,7 @@ }, { "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-bom", - "artifactVersion": "1.7.3", + "artifactVersion": "1.11.0", "name": "kotlinx-serialization-bom", "description": "Kotlin multiplatform serialization runtime library", "website": "https://github.com/Kotlin/kotlinx.serialization", @@ -2873,8 +2874,8 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core-jvm", - "artifactVersion": "1.7.3", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core", + "artifactVersion": "1.11.0", "name": "kotlinx-serialization-core", "description": "Kotlin multiplatform serialization runtime library", "website": "https://github.com/Kotlin/kotlinx.serialization", @@ -2895,7 +2896,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json-jvm", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json", "artifactVersion": "1.11.0", "name": "kotlinx-serialization-json", "description": "Kotlin multiplatform serialization runtime library", @@ -3133,9 +3134,8 @@ ], "licenses": { "Apache-2.0": { - "name": "Apache License 2.0", - "url": "https://spdx.org/licenses/Apache-2.0.html", - "content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\nTo apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.", + "name": "The Apache Software License, Version 2.0", + "url": "https://www.apache.org/licenses/LICENSE-2.0.txt", "internalHash": "Apache-2.0", "spdxId": "Apache-2.0", "hash": "Apache-2.0" diff --git a/sample/web/src/commonMain/composeResources/files/aboutlibraries.json b/sample/web/src/commonMain/composeResources/files/aboutlibraries.json index 68e883021..e1a64a82a 100644 --- a/sample/web/src/commonMain/composeResources/files/aboutlibraries.json +++ b/sample/web/src/commonMain/composeResources/files/aboutlibraries.json @@ -1,7 +1,7 @@ { "libraries": [ { - "uniqueId": "androidx.annotation:annotation-wasm-js", + "uniqueId": "androidx.annotation:annotation", "artifactVersion": "1.9.1", "name": "Annotation", "description": "Provides source annotations for tooling and readability.", @@ -26,7 +26,7 @@ ] }, { - "uniqueId": "androidx.collection:collection-wasm-js", + "uniqueId": "androidx.collection:collection", "artifactVersion": "1.5.0", "name": "collections", "description": "Standalone efficient collections.", @@ -51,10 +51,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-annotation-wasm-js", + "uniqueId": "androidx.compose.runtime:runtime", "artifactVersion": "1.11.2", - "name": "Compose Runtime Annotation", - "description": "Provides Compose-specific annotations used by the compiler and tooling", + "name": "Compose Runtime", + "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -76,10 +76,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-retain-wasm-js", + "uniqueId": "androidx.compose.runtime:runtime-annotation", "artifactVersion": "1.11.2", - "name": "Compose Runtime Retain", - "description": "Preserve state in composable methods across configuration changes and other transient content destruction scenarios", + "name": "Compose Runtime Annotation", + "description": "Provides Compose-specific annotations used by the compiler and tooling", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -101,10 +101,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-saveable-wasm-js", + "uniqueId": "androidx.compose.runtime:runtime-retain", "artifactVersion": "1.11.2", - "name": "Compose Saveable", - "description": "Compose components that allow saving and restoring the local ui state", + "name": "Compose Runtime Retain", + "description": "Preserve state in composable methods across configuration changes and other transient content destruction scenarios", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -126,10 +126,10 @@ ] }, { - "uniqueId": "androidx.compose.runtime:runtime-wasm-js", + "uniqueId": "androidx.compose.runtime:runtime-saveable", "artifactVersion": "1.11.2", - "name": "Compose Runtime", - "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", + "name": "Compose Saveable", + "description": "Compose components that allow saving and restoring the local ui state", "website": "https://developer.android.com/jetpack/androidx/releases/compose-runtime#1.11.2", "developers": [ { @@ -151,7 +151,7 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-common-wasm-js", + "uniqueId": "androidx.lifecycle:lifecycle-common", "artifactVersion": "2.9.4", "name": "Lifecycle-Common", "description": "Android Lifecycle-Common", @@ -176,10 +176,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose-wasm-js", + "uniqueId": "androidx.lifecycle:lifecycle-runtime", "artifactVersion": "2.9.4", - "name": "Lifecycle Runtime Compose", - "description": "Compose integration with Lifecycle", + "name": "Lifecycle Runtime", + "description": "Android Lifecycle Runtime", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -201,10 +201,10 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-runtime-wasm-js", + "uniqueId": "androidx.lifecycle:lifecycle-runtime-compose", "artifactVersion": "2.9.4", - "name": "Lifecycle Runtime", - "description": "Android Lifecycle Runtime", + "name": "Lifecycle Runtime Compose", + "description": "Compose integration with Lifecycle", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ { @@ -226,9 +226,9 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate-wasm-js", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel", "artifactVersion": "2.9.4", - "name": "Lifecycle ViewModel with SavedState", + "name": "Lifecycle ViewModel", "description": "Android Lifecycle ViewModel", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ @@ -251,9 +251,9 @@ ] }, { - "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-wasm-js", + "uniqueId": "androidx.lifecycle:lifecycle-viewmodel-savedstate", "artifactVersion": "2.9.4", - "name": "Lifecycle ViewModel", + "name": "Lifecycle ViewModel with SavedState", "description": "Android Lifecycle ViewModel", "website": "https://developer.android.com/jetpack/androidx/releases/lifecycle#2.9.4", "developers": [ @@ -276,7 +276,7 @@ ] }, { - "uniqueId": "androidx.navigationevent:navigationevent-wasm-js", + "uniqueId": "androidx.navigationevent:navigationevent", "artifactVersion": "1.0.1", "name": "Navigation Event", "description": "Provides APIs to easily intercept platform navigation events, including swipes and clicks, to provide a consistent API surface for handling these events.", @@ -301,10 +301,10 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-compose-wasm-js", + "uniqueId": "androidx.savedstate:savedstate", "artifactVersion": "1.4.0", - "name": "Saved State Compose", - "description": "Compose integration with Saved State", + "name": "Saved State", + "description": "Android Lifecycle Saved State", "website": "https://developer.android.com/jetpack/androidx/releases/savedstate#1.4.0", "developers": [ { @@ -326,10 +326,10 @@ ] }, { - "uniqueId": "androidx.savedstate:savedstate-wasm-js", + "uniqueId": "androidx.savedstate:savedstate-compose", "artifactVersion": "1.4.0", - "name": "Saved State", - "description": "Android Lifecycle Saved State", + "name": "Saved State Compose", + "description": "Compose integration with Saved State", "website": "https://developer.android.com/jetpack/androidx/releases/savedstate#1.4.0", "developers": [ { @@ -351,30 +351,7 @@ ] }, { - "uniqueId": "com.github.skydoves:compose-stability-runtime-wasm-js", - "artifactVersion": "0.9.0", - "name": "Compose Stability Analyzer Runtime", - "description": "A Compose Compiler plugin that analyzes composable functions and generates stability reports.", - "website": "https://github.com/skydoves/compose-stability-analyzer/", - "developers": [ - { - "name": "Jaewoong Eum" - } - ], - "scm": { - "connection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "developerConnection": "scm:git:git://github.com/skydoves/compose-stability-analyzer.git", - "url": "https://github.com/skydoves/compose-stability-analyzer/" - }, - "licenses": [ - "Apache-2.0" - ], - "funding": [ - - ] - }, - { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-common-wasm-js", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-common", "artifactVersion": "2.9.6", "name": "Lifecycle-Common", "description": "Android Lifecycle-Common", @@ -398,10 +375,10 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime-compose-wasm-js", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime", "artifactVersion": "2.9.6", - "name": "Lifecycle Runtime Compose", - "description": "Compose integration with Lifecycle", + "name": "Lifecycle Runtime", + "description": "Android Lifecycle Runtime", "website": "https://github.com/JetBrains/compose-jb", "developers": [ { @@ -422,10 +399,10 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime-wasm-js", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-runtime-compose", "artifactVersion": "2.9.6", - "name": "Lifecycle Runtime", - "description": "Android Lifecycle Runtime", + "name": "Lifecycle Runtime Compose", + "description": "Compose integration with Lifecycle", "website": "https://github.com/JetBrains/compose-jb", "developers": [ { @@ -446,9 +423,9 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-savedstate-wasm-js", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel", "artifactVersion": "2.9.6", - "name": "Lifecycle ViewModel with SavedState", + "name": "Lifecycle ViewModel", "description": "Android Lifecycle ViewModel", "website": "https://github.com/JetBrains/compose-jb", "developers": [ @@ -470,9 +447,9 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-wasm-js", + "uniqueId": "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-savedstate", "artifactVersion": "2.9.6", - "name": "Lifecycle ViewModel", + "name": "Lifecycle ViewModel with SavedState", "description": "Android Lifecycle ViewModel", "website": "https://github.com/JetBrains/compose-jb", "developers": [ @@ -494,10 +471,10 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.savedstate:savedstate-compose-wasm-js", + "uniqueId": "org.jetbrains.androidx.savedstate:savedstate", "artifactVersion": "1.3.6", - "name": "Saved State Compose", - "description": "Compose integration with Saved State", + "name": "Saved State", + "description": "Android Lifecycle Saved State", "website": "https://github.com/JetBrains/compose-jb", "developers": [ { @@ -518,10 +495,10 @@ ] }, { - "uniqueId": "org.jetbrains.androidx.savedstate:savedstate-wasm-js", + "uniqueId": "org.jetbrains.androidx.savedstate:savedstate-compose", "artifactVersion": "1.3.6", - "name": "Saved State", - "description": "Android Lifecycle Saved State", + "name": "Saved State Compose", + "description": "Compose integration with Saved State", "website": "https://github.com/JetBrains/compose-jb", "developers": [ { @@ -542,10 +519,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.animation:animation-core-wasm-js", + "uniqueId": "org.jetbrains.compose.animation:animation", "artifactVersion": "1.11.1", - "name": "Compose Animation Core", - "description": "Animation engine and animation primitives that are the building blocks of the Compose animation library", + "name": "Compose Animation", + "description": "Compose animation library", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -566,10 +543,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.animation:animation-wasm-js", + "uniqueId": "org.jetbrains.compose.animation:animation-core", "artifactVersion": "1.11.1", - "name": "Compose Animation", - "description": "Compose animation library", + "name": "Compose Animation Core", + "description": "Animation engine and animation primitives that are the building blocks of the Compose animation library", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -590,7 +567,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.annotation-internal:annotation-wasm-js", + "uniqueId": "org.jetbrains.compose.annotation-internal:annotation", "artifactVersion": "1.10.0", "name": "Annotation", "description": "Provides source annotations for tooling and readability.", @@ -614,7 +591,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.collection-internal:collection-wasm-js", + "uniqueId": "org.jetbrains.compose.collection-internal:collection", "artifactVersion": "1.10.0", "name": "collections", "description": "Standalone efficient collections.", @@ -638,7 +615,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.components:components-resources-wasmJs", + "uniqueId": "org.jetbrains.compose.components:components-resources", "artifactVersion": "1.11.1", "name": "Resources for Compose JB", "description": "Resources for Compose JB", @@ -662,10 +639,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.foundation:foundation-layout-wasm-js", + "uniqueId": "org.jetbrains.compose.foundation:foundation", "artifactVersion": "1.11.1", - "name": "Compose Layouts", - "description": "Compose layout implementations", + "name": "Compose Foundation", + "description": "Higher level abstractions of the Compose UI primitives. This library is design system agnostic, providing the high-level building blocks for both application and design-system developers", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -686,10 +663,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.foundation:foundation-wasm-js", + "uniqueId": "org.jetbrains.compose.foundation:foundation-layout", "artifactVersion": "1.11.1", - "name": "Compose Foundation", - "description": "Higher level abstractions of the Compose UI primitives. This library is design system agnostic, providing the high-level building blocks for both application and design-system developers", + "name": "Compose Layouts", + "description": "Compose layout implementations", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -710,7 +687,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material3:material3-wasm-js", + "uniqueId": "org.jetbrains.compose.material3:material3", "artifactVersion": "1.9.0", "name": "Compose Material3 Components", "description": "Compose Material You Design Components library", @@ -734,7 +711,31 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-icons-core-wasm-js", + "uniqueId": "org.jetbrains.compose.material:material", + "artifactVersion": "1.11.1", + "name": "Compose Material Components", + "description": "Compose Material Design Components library", + "website": "https://github.com/JetBrains/compose-multiplatform", + "developers": [ + { + "name": "Compose Multiplatform Team", + "organisationUrl": "https://www.jetbrains.com" + } + ], + "scm": { + "connection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "developerConnection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", + "url": "https://github.com/JetBrains/compose-multiplatform" + }, + "licenses": [ + "Apache-2.0" + ], + "funding": [ + + ] + }, + { + "uniqueId": "org.jetbrains.compose.material:material-icons-core", "artifactVersion": "1.7.3", "name": "Compose Material Icons Core", "description": "Compose Material Design core icons. This module contains the most commonly used set of Material icons.", @@ -758,7 +759,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-icons-extended-wasm-js", + "uniqueId": "org.jetbrains.compose.material:material-icons-extended", "artifactVersion": "1.7.3", "name": "Compose Material Icons Extended", "description": "Compose Material Design extended icons. This module contains all Material icons. It is a very large dependency and should not be included directly.", @@ -782,7 +783,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-ripple-wasm-js", + "uniqueId": "org.jetbrains.compose.material:material-ripple", "artifactVersion": "1.11.1", "name": "Compose Material Ripple", "description": "Material ripple used to build interactive components", @@ -806,10 +807,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.material:material-wasm-js", + "uniqueId": "org.jetbrains.compose.runtime:runtime", "artifactVersion": "1.11.1", - "name": "Compose Material Components", - "description": "Compose Material Design Components library", + "name": "Compose Runtime", + "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -830,7 +831,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.runtime:runtime-saveable-wasm-js", + "uniqueId": "org.jetbrains.compose.runtime:runtime-saveable", "artifactVersion": "1.11.1", "name": "Compose Saveable", "description": "Compose components that allow saving and restoring the local ui state", @@ -854,10 +855,10 @@ ] }, { - "uniqueId": "org.jetbrains.compose.runtime:runtime-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui", "artifactVersion": "1.11.1", - "name": "Compose Runtime", - "description": "Tree composition support for code generated by the Compose compiler plugin and corresponding public API", + "name": "Compose UI", + "description": "Compose UI primitives. This library contains the primitives that form the Compose UI Toolkit, such as drawing, measurement and layout.", "website": "https://github.com/JetBrains/compose-multiplatform", "developers": [ { @@ -878,7 +879,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-backhandler-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-backhandler", "artifactVersion": "1.11.1", "name": "Compose BackHandler", "description": "Provides BackHandler in Compose Multiplatform projects", @@ -902,7 +903,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-geometry-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-geometry", "artifactVersion": "1.11.1", "name": "Compose Geometry", "description": "Compose classes related to dimensions without units", @@ -926,7 +927,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-graphics-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-graphics", "artifactVersion": "1.11.1", "name": "Compose Graphics", "description": "Compose graphics", @@ -950,7 +951,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-text-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-text", "artifactVersion": "1.11.1", "name": "Compose UI Text", "description": "Compose Text primitives and utilities", @@ -974,7 +975,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-unit-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-unit", "artifactVersion": "1.11.1", "name": "Compose Unit", "description": "Compose classes for simple units", @@ -998,7 +999,7 @@ ] }, { - "uniqueId": "org.jetbrains.compose.ui:ui-util-wasm-js", + "uniqueId": "org.jetbrains.compose.ui:ui-util", "artifactVersion": "1.11.1", "name": "Compose Util", "description": "Internal Compose utilities used by other modules", @@ -1021,33 +1022,9 @@ ] }, - { - "uniqueId": "org.jetbrains.compose.ui:ui-wasm-js", - "artifactVersion": "1.11.1", - "name": "Compose UI", - "description": "Compose UI primitives. This library contains the primitives that form the Compose UI Toolkit, such as drawing, measurement and layout.", - "website": "https://github.com/JetBrains/compose-multiplatform", - "developers": [ - { - "name": "Compose Multiplatform Team", - "organisationUrl": "https://www.jetbrains.com" - } - ], - "scm": { - "connection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", - "developerConnection": "scm:git:https://github.com/JetBrains/compose-multiplatform.git", - "url": "https://github.com/JetBrains/compose-multiplatform" - }, - "licenses": [ - "Apache-2.0" - ], - "funding": [ - - ] - }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib", "description": "Kotlin Standard Library", "website": "https://kotlinlang.org/", @@ -1071,7 +1048,7 @@ }, { "uniqueId": "org.jetbrains.kotlin:kotlin-stdlib-wasm-js", - "artifactVersion": "2.4.0", + "artifactVersion": "2.4.10", "name": "Kotlin Stdlib Wasm Js", "description": "Kotlin Standard Library for experimental WebAssembly JS platform", "website": "https://kotlinlang.org/", @@ -1094,8 +1071,8 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:atomicfu-wasm-js", - "artifactVersion": "0.25.0", + "uniqueId": "org.jetbrains.kotlinx:atomicfu", + "artifactVersion": "0.28.0", "name": "atomicfu", "description": "AtomicFU utilities", "website": "https://github.com/Kotlin/kotlinx.atomicfu", @@ -1116,7 +1093,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-browser-wasm-js", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-browser", "artifactVersion": "0.5.0", "name": "kotlinx-browser", "description": "Kotlinx Browser", @@ -1138,7 +1115,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core-wasm-js", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-coroutines-core", "artifactVersion": "1.9.0", "name": "kotlinx-coroutines-core", "description": "Coroutines support libraries for Kotlin", @@ -1160,7 +1137,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime-wasm-js", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-datetime", "artifactVersion": "0.7.1", "name": "kotlinx-datetime", "description": "Kotlin Datetime Library", @@ -1182,8 +1159,8 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core-wasm-js", - "artifactVersion": "1.7.3", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-core", + "artifactVersion": "1.11.0", "name": "kotlinx-serialization-core", "description": "Kotlin multiplatform serialization runtime library", "website": "https://github.com/Kotlin/kotlinx.serialization", @@ -1204,7 +1181,7 @@ ] }, { - "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json-wasm-js", + "uniqueId": "org.jetbrains.kotlinx:kotlinx-serialization-json", "artifactVersion": "1.11.0", "name": "kotlinx-serialization-json", "description": "Kotlin multiplatform serialization runtime library", From 7d4b80425fe04c8ef5dab8ee2c101f29e3a02aa7 Mon Sep 17 00:00:00 2001 From: Mike Penz Date: Fri, 21 Aug 2026 17:35:13 +0200 Subject: [PATCH 7/7] - [release] v15.1.1 --- README.md | 2 +- gradle.properties | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4ef8cf9a9..ed66a88ec 100644 --- a/README.md +++ b/README.md @@ -98,7 +98,7 @@ Tapping a library opens its details — inline, in a dialog, or in a bottom shee ## Latest releases 🛠 -- Compose 1.11.x | New UI | AGP 9 | Kotlin 2.4 | Compile 37 | [v15.1.0](https://github.com/mikepenz/AboutLibraries/tree/15.1.0) +- Compose 1.11.x | New UI | AGP 9 | Kotlin 2.4 | Compile 37 | [v15.1.1](https://github.com/mikepenz/AboutLibraries/tree/15.1.1) - Compose 1.10.x | AGP 9 | [v14.1.0](https://github.com/mikepenz/AboutLibraries/tree/14.1.0) ## Gradle Plugin diff --git a/gradle.properties b/gradle.properties index 7d947c31e..1d68ef62b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,7 +1,7 @@ GROUP=com.mikepenz -VERSION_NAME=15.1.0 -VERSION_CODE=150100 +VERSION_NAME=15.1.1 +VERSION_CODE=150101 POM_URL=https://github.com/mikepenz/AboutLibraries POM_SCM_URL=https://github.com/mikepenz/AboutLibraries