Version 1.3.10.5

Author: EssentialGGBot

.gitattributes

@@ -1,4 +1,5 @@
 *   eol=lf
+*.bat   text eol=crlf
 *.der   binary
 *.otf	binary
 *.ttf	binary

.github/workflows/main.yml

@@ -14,7 +14,7 @@ jobs:
 
       - uses: actions/setup-java@v3
         with:
-          distribution: temurin
+          distribution: corretto
           java-version: |
             8
             16

api/api/api.api

@@ -299,12 +299,20 @@ public class gg/essential/api/gui/EssentialGUI : gg/essential/elementa/WindowScr
 	public fun <init> (Ljava/lang/String;IZ)V
 	public synthetic fun <init> (Ljava/lang/String;IZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun getBackButtonVisible ()Z
+	protected fun getBackgroundColor ()Ljava/awt/Color;
+	protected fun getButtonColor ()Ljava/awt/Color;
+	protected fun getButtonHighlightColor ()Ljava/awt/Color;
 	protected final fun getContainer ()Lgg/essential/elementa/components/UIContainer;
 	public final fun getContent ()Lgg/essential/elementa/components/UIContainer;
+	protected fun getContentEdgesColor ()Ljava/awt/Color;
 	public final fun getDiscordActivityDescription ()Ljava/lang/String;
 	public final fun getRightDivider ()Lgg/essential/elementa/components/UIBlock;
 	public final fun getScissorBox ()Lgg/essential/elementa/components/UIContainer;
+	protected fun getTextColor ()Ljava/awt/Color;
+	protected fun getTextHighlightColor ()Ljava/awt/Color;
+	protected fun getTitleBackgroundColor ()Ljava/awt/Color;
 	public final fun getTitleBar ()Lgg/essential/elementa/components/UIBlock;
+	protected fun getTitleEdgesColor ()Ljava/awt/Color;
 	public final fun getTitleText ()Lgg/essential/elementa/components/UIWrappedText;
 	public final fun setBackButtonVisible (Z)V
 	public final fun setTitle (Ljava/lang/String;)V

api/build.gradle.kts

@@ -25,7 +25,7 @@ val mcPlatform = platform.loaderStr
 
 group = "gg.essential"
 base.archivesName.set("EssentialAPI " + project.name)
-tasks.compileKotlin { kotlinOptions.moduleName = "essential-api" }
+kotlin.compilerOptions.moduleName.set("essential-api")
 java.withSourcesJar()
 loom.noRunConfigs() // can't run just the API, only the implementation
 configureDokkaForEssentialApi()

api/src/main/kotlin/gg/essential/api/gui/EssentialGUI.kt

@@ -84,8 +84,16 @@ open class EssentialGUI(
     @get:ApiStatus.Internal
     protected val outlineThickness = 3f
 
-
-    private val background by UIBlock(BACKGROUND).constrain {
+    protected open fun getTitleBackgroundColor(): Color = Color(0x232323)
+    protected open fun getTitleEdgesColor(): Color = Color(0x303030)
+    protected open fun getBackgroundColor(): Color = Color(0x181818)
+    protected open fun getContentEdgesColor(): Color = Color(0x232323)
+    protected open fun getButtonColor(): Color = Color(0x323232)
+    protected open fun getButtonHighlightColor(): Color = Color(0x474747)
+    protected open fun getTextColor(): Color = Color(0xBFBFBF)
+    protected open fun getTextHighlightColor(): Color = Color(0xE5E5E5)
+
+    private val background by UIBlock(getBackgroundColor()).constrain {
         width = 100.percent
         height = 100.percent
     } childOf window
@@ -104,22 +112,22 @@ open class EssentialGUI(
         height = 75.percent
     } childOf window
 
-    private val leftDivider by UIBlock(DARK_GRAY).constrain {
+    private val leftDivider by UIBlock(getContentEdgesColor()).constrain {
         x = SiblingConstraint(alignOpposite = true)
         y = componentYConstraint(container)
         width = outlineThickness.pixels
         height = componentHeightConstraint(container)
     } childOf window
 
-    val rightDivider by UIBlock(DARK_GRAY).constrain {
+    val rightDivider by UIBlock(getContentEdgesColor()).constrain {
         x = SiblingConstraint() boundTo container
         y = componentYConstraint(container)
         width = outlineThickness.pixels
         height = componentHeightConstraint(container)
     } childOf window
 
     @get:ApiStatus.Internal
-    val bottomDivider by UIBlock(DARK_GRAY).constrain {
+    val bottomDivider by UIBlock(getContentEdgesColor()).constrain {
         x = componentXConstraint(leftDivider)
         y = SiblingConstraint()
         width =
@@ -128,15 +136,15 @@ open class EssentialGUI(
     } childOf window
 
 
-    val titleBar by UIBlock(DARK_GRAY).constrain {
+    val titleBar by UIBlock(getTitleBackgroundColor()).constrain {
         width = 100.percent
         height = 30.pixels
     } childOf container
 
     val titleText by UIWrappedText(guiTitle).constrain {
         x = 10.pixels
         y = 11.pixels
-        color = TEXT_HIGHLIGHT.toConstraint()
+        color = getTextHighlightColor().toConstraint()
     } childOf titleBar
 
     val content by UIContainer().constrain {
@@ -157,14 +165,14 @@ open class EssentialGUI(
 
     init {
         // Notches in titlebar
-        UIBlock(COMPONENT_HIGHLIGHT).constrain {
+        UIBlock(getTitleEdgesColor()).constrain {
             x = 0.pixels(alignOutside = true) boundTo titleBar
             y = 0.pixels boundTo titleBar
             height = 100.percent boundTo titleBar
             width = outlineThickness.pixels
         } childOf window
 
-        UIBlock(COMPONENT_HIGHLIGHT).constrain {
+        UIBlock(getTitleEdgesColor()).constrain {
             x = 0.pixels(alignOpposite = true, alignOutside = true) boundTo titleBar
             y = 0.pixels boundTo titleBar
             height = 100.percent boundTo titleBar
@@ -185,13 +193,4 @@ open class EssentialGUI(
     fun setTitle(newTitle: String) {
         titleText.setText(newTitle)
     }
-    private companion object EssentialGuiPalette {
-        private val BACKGROUND = Color(0x181818)
-        private val DARK_GRAY: Color = Color(0x232323)
-        private val BUTTON = Color(0x323232)
-        private val BUTTON_HIGHLIGHT = Color(0x474747)
-        private var TEXT = Color(0xBFBFBF)
-        private var TEXT_HIGHLIGHT = Color(0xE5E5E5)
-        private val COMPONENT_HIGHLIGHT = Color(0x303030)
-    }
 }

build-logic/build.gradle.kts

@@ -26,7 +26,7 @@ dependencies {
     implementation(gradleApi())
     implementation(localGroovy())
 
-    val kotlinCompilerVersion = "1.9.24"
+    val kotlinCompilerVersion = "2.3.0"
 
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinCompilerVersion")
     implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinCompilerVersion")
@@ -37,8 +37,8 @@ dependencies {
     implementation("org.ow2.asm:asm-commons:9.3")
     implementation ("com.google.guava:guava:30.1.1-jre")
 
-    implementation("gg.essential:essential-gradle-toolkit:0.6.10")
-    implementation("gg.essential.loom:gg.essential.loom.gradle.plugin:1.7.35") // TODO remove once EGT has updated
+    implementation("gg.essential:essential-gradle-toolkit:0.7.0-alpha.2")
+    // FIXME remove the forced remap version in `root.gradle.kts` once EGT updates its remap
 }
 
 gradlePlugin {

build-logic/src/main/kotlin/essential/SyncToExternalRepoTask.kt

@@ -12,16 +12,17 @@
 package essential
 
 import org.gradle.api.DefaultTask
-import org.gradle.api.Project
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.TaskAction
 import org.gradle.kotlin.dsl.*
+import org.gradle.process.ExecOperations
 import org.gradle.process.ExecSpec
 import java.io.ByteArrayOutputStream
 import java.nio.file.Files
 import java.nio.file.Path
+import javax.inject.Inject
 import kotlin.io.path.pathString
 
 private val sourceCommitRegex = Regex("Source-Commit: (\\w+)")
@@ -43,6 +44,9 @@ abstract class SyncToExternalRepoTask : DefaultTask() {
 
     private val srcRepoPath = project.rootDir.toPath()
 
+    @get:Inject
+    protected abstract val execOperations: ExecOperations
+
     @TaskAction
     fun sync() {
         //make sure the target directories exist in the target repository
@@ -54,7 +58,7 @@ abstract class SyncToExternalRepoTask : DefaultTask() {
         }
         // get synced commit(s) in the target repo
         val targetFilters = targetDirectories.get().toTypedArray()
-        val syncedCommitMessages = project.git(_targetRepoPath, "log", "--format=%b", "-E", "--grep=${sourceCommitRegex.pattern}", "--", *targetFilters)
+        val syncedCommitMessages = git(_targetRepoPath, "log", "--format=%b", "-E", "--grep=${sourceCommitRegex.pattern}", "--", *targetFilters)
         // parse the source commit hash(es)
         val syncedCommits = sourceCommitRegex.findAll(syncedCommitMessages).map { it.groupValues[1] }.toSet()
         val latestSyncedCommit = syncedCommits.firstOrNull()
@@ -65,7 +69,7 @@ abstract class SyncToExternalRepoTask : DefaultTask() {
         // Here we use a format string without speficying the leading `format:` which results in linebreaks following
         // each line. We then split by linebreak and drop the last one as the trailing linebreak results in a single
         // empty string
-        val commitsToSync = project.git(srcRepoPath, "log", "--format=%H %s", "--reverse", "--topo-order", revisionsSinceLastSyncedCommit, "--", *sourceFilters)
+        val commitsToSync = git(srcRepoPath, "log", "--format=%H %s", "--reverse", "--topo-order", revisionsSinceLastSyncedCommit, "--", *sourceFilters)
             .split("\n")
             .dropLast(1)
         if (commitsToSync.isEmpty()) {
@@ -79,32 +83,32 @@ abstract class SyncToExternalRepoTask : DefaultTask() {
             }
             println("Applying $commit $subject")
             // get diff of current commit
-            val diff = project.git(srcRepoPath, "show",  commit, "--remerge-diff", "--", *sourceFilters)
+            val diff = git(srcRepoPath, "show",  commit, "--remerge-diff", "--", *sourceFilters)
             // process diff by applying replacements
             val processed = replacements.get().fold(diff) { processing, (replaced, replacement) ->
                 processing.replace(replaced, replacement)
             }
             // apply commit diff using stdin
             try {
-                project.git(_targetRepoPath, "apply", "--allow-empty") {
+                git(_targetRepoPath, "apply", "--allow-empty") {
                     standardInput = processed.byteInputStream()
                 }
             } catch (e: Exception) {
-                project.git(_targetRepoPath, "apply", "--reject", "--allow-empty") {
+                git(_targetRepoPath, "apply", "--reject", "--allow-empty") {
                     standardInput = processed.byteInputStream()
                 }
             }
             // ignore commit if diff was empty (e.g. trivial merge commit)
-            if (project.git(_targetRepoPath, "status", "--porcelain").isBlank()) {
+            if (git(_targetRepoPath, "status", "--porcelain").isBlank()) {
                 return@forEach
             }
             // stage changes
-            project.git(_targetRepoPath, "add", "--", *targetFilters)
+            git(_targetRepoPath, "add", "--", *targetFilters)
             // get source commit message
-            val srcCommitMsg = project.git(srcRepoPath, "show", "--format=%B", "--no-patch", commit)
+            val srcCommitMsg = git(srcRepoPath, "show", "--format=%B", "--no-patch", commit)
             val srcCommitData = configureCommitData(commit)
             // commit changes
-            project.git(_targetRepoPath, "commit", "-m", "$srcCommitMsg\n" +
+            git(_targetRepoPath, "commit", "-m", "$srcCommitMsg\n" +
                     "Source-Commit: $commit") {
                 environment(srcCommitData)
             }
@@ -113,18 +117,17 @@ abstract class SyncToExternalRepoTask : DefaultTask() {
 
     private fun configureCommitData(hash: String): Map<String, String> =
         mapOf(
-            "GIT_COMMITER_NAME" to project.git(srcRepoPath, "show", "--format=%cn", "--no-patch", hash),
-            "GIT_COMMITER_EMAIL" to project.git(srcRepoPath, "show", "--format=%ce", "--no-patch", hash),
-            "GIT_COMMITER_DATE" to project.git(srcRepoPath, "show", "--format=%ai", "--no-patch", hash),
-            "GIT_AUTHOR_NAME" to project.git(srcRepoPath, "show", "--format=%an", "--no-patch", hash),
-            "GIT_AUTHOR_EMAIL" to project.git(srcRepoPath, "show", "--format=%ae", "--no-patch", hash),
-            "GIT_AUTHOR_DATE" to project.git(srcRepoPath, "show", "--format=%ai", "--no-patch", hash),
+            "GIT_COMMITER_NAME" to git(srcRepoPath, "show", "--format=%cn", "--no-patch", hash),
+            "GIT_COMMITER_EMAIL" to git(srcRepoPath, "show", "--format=%ce", "--no-patch", hash),
+            "GIT_COMMITER_DATE" to git(srcRepoPath, "show", "--format=%ai", "--no-patch", hash),
+            "GIT_AUTHOR_NAME" to git(srcRepoPath, "show", "--format=%an", "--no-patch", hash),
+            "GIT_AUTHOR_EMAIL" to git(srcRepoPath, "show", "--format=%ae", "--no-patch", hash),
+            "GIT_AUTHOR_DATE" to git(srcRepoPath, "show", "--format=%ai", "--no-patch", hash),
         )
-}
 
-private fun Project.git(workingDirectory: Path, command: String, vararg args: String, configure: ExecSpec.() -> Unit = {}) =
-    ByteArrayOutputStream().use { stream ->
-        project.exec {
+    private fun git(workingDirectory: Path, command: String, vararg args: String, configure: ExecSpec.() -> Unit = {}): String {
+        val stream = ByteArrayOutputStream()
+        execOperations.exec {
             commandLine("git")
             args("-C", workingDirectory.pathString)
             args(command)
@@ -144,5 +147,6 @@ private fun Project.git(workingDirectory: Path, command: String, vararg args: St
                 }
             }
         }
-        stream.toString()
-    }
+        return stream.toString()
+    }
+}

build-logic/src/main/kotlin/essential/embedded-loader.gradle.kts

@@ -14,7 +14,7 @@ package essential
 import gg.essential.gradle.multiversion.Platform
 import java.nio.file.FileSystems
 import java.nio.file.Files
-import kotlin.io.path.nameWithoutExtension
+import java.nio.file.StandardCopyOption
 
 plugins {
     java
@@ -23,10 +23,10 @@ plugins {
 val platform: Platform by extensions
 
 val dependency = when {
-    platform.isFabric -> "gg.essential:loader-fabric:1.2.1"
-    platform.isModLauncher && platform.mcVersion >= 11700 -> "gg.essential:loader-modlauncher9:1.2.1"
-    platform.isModLauncher -> "gg.essential:loader-modlauncher8:1.2.1"
-    platform.isLegacyForge -> "gg.essential:loader-launchwrapper:1.2.1"
+    platform.isFabric -> "gg.essential:loader-fabric"
+    platform.isModLauncher && platform.mcVersion >= 11700 -> "gg.essential:loader-modlauncher9"
+    platform.isModLauncher -> "gg.essential:loader-modlauncher8"
+    platform.isLegacyForge -> "gg.essential:loader-launchwrapper"
     else -> throw UnsupportedOperationException("No known loader variant for current platform.")
 }
 
@@ -61,41 +61,36 @@ tasks.jar {
 }
 
 /**
- * Takes the stage1 jar from the input stage0 jar and copies it to a different location in the output jar.
+ * Extracts the stage1 jar from the given input stage0 jar.
  * We do this so we don't need to do any double-unpacking at runtime when we upgrade the installed stage1 version, and
  * because the raw loader stored above will actually be stripped when the Essential jar is installed via stage2 (because
  * the regular upgrade path would break with relaunching; we instead need to use the `stage1.update.jar` path).
  */
-abstract class Stage1JarTransform : TransformAction<TransformParameters.None> {
-    @get:InputArtifact
-    abstract val input: Provider<FileSystemLocation>
+abstract class ExtractStage1JarTask : DefaultTask() {
+    @get:InputFile
+    abstract val stage0: RegularFileProperty
+    @get:OutputFile
+    abstract val stage1: RegularFileProperty
 
-    override fun transform(outputs: TransformOutputs) {
-        val input = input.get().asFile.toPath()
-        val output = outputs.file(input.nameWithoutExtension + "-stage1-only.jar").toPath()
+    @TaskAction
+    fun extract() {
+        val input = stage0.get().asFile.toPath()
+        val output = stage1.get().asFile.toPath()
         FileSystems.newFileSystem(input, null as ClassLoader?).use { sourceFs ->
             val source = sourceFs.getPath("gg/essential/loader/stage0/stage1.jar")
-            FileSystems.newFileSystem(output, mapOf("create" to true)).use { targetFs ->
-                val target = targetFs.getPath("gg/essential/loader-stage1.jar")
-                Files.createDirectories(target.parent)
-                Files.copy(source, target)
-            }
+            Files.createDirectories(output.parent)
+            Files.copy(source, output, StandardCopyOption.REPLACE_EXISTING)
         }
     }
 }
 
-dependencies {
-    val attr = Attribute.of("stage1Jar", Boolean::class.javaObjectType)
-    dependencies.registerTransform(Stage1JarTransform::class.java) {
-        from.attribute(attr, false)
-        to.attribute(attr, true)
-    }
-    dependencies.artifactTypes.all {
-        attributes.attribute(attr, false)
+val extractStage1Jar by tasks.registering(ExtractStage1JarTask::class) {
+    stage0.fileProvider(loader.elements.map { it.single().asFile })
+    stage1.set(layout.buildDirectory.file("loader-stage1.jar"))
+}
+
+tasks.named<Jar>("bundleJar") {
+    from(extractStage1Jar.flatMap { it.stage1 }) {
+        into("gg/essential/")
     }
-    // Note: May need to pre-bundle this if we ever want to have the real thing on the classpath too; each dependency
-    //       can only be present once per configuration.
-    implementation("bundle"(dependency) {
-        attributes { attribute(attr, true) }
-    })
 }