Version 1.3.10.1

Author: EssentialGGBot

build-logic/src/main/kotlin/gg/essential/gradle/RelocatePlugin.kt

@@ -135,6 +135,7 @@ private fun Project.createAbiValidationTasks(relocateTask: TaskProvider<Relocate
             "gg.essential.image",
             "gg.essential.key",
             "gg.essential.main",
+            "gg.essential.minecraftauth",
             "gg.essential.mixins",
             "gg.essential.mod",
             "gg.essential.model",

build.gradle.kts

@@ -81,6 +81,7 @@ dependencies {
     implementation(bundle(project(":clipboard"))!!)
     implementation(bundle(project(":utils"))!!)
     implementation(bundle(project(":plasmo"))!!)
+    implementation(bundle(project(":minecraft-auth"))!!)
     if (platform.mcVersion >= 11800) {
         implementation(bundle(project(":immediatelyfast"))!!)
     }

changelog/release-1.3.10.1.md

@@ -0,0 +1,14 @@
+Title: Bug Patch
+Summary: Minor bug fixes
+
+## Improvements
+- Added an Alternative Menu for accessing Essential screens, accessed via the 'G' key
+
+## Bug Fixes
+- Fixed some transparent particles rendering incorrectly
+- Fixed purchase confirmation modal not closing after clicking purchase
+- Fixed default resource-packs being able to be disabled via drag & dropping
+- Fixed IndexOutOfBoundsException when dragging the bottom resource-pack entry in a list
+
+## Compatibility
+- Fixed GL_INVALID_OPERATION errors with mods which use NeoForge's `RenderTarget.enableStencil` feature

changelog/release-1.3.10.md

@@ -1,11 +1,12 @@
-Title: Bug Patch
-Summary: Minor bug fixes
+Title: Player safety
+Summary: Improved player and chat safety
 
 ## Social
 - Added Community Rules modal, which must be accepted before being able to engage with social features
 - Added modal to mute or block user after reporting them
 - Added notification to confirm when a user has been successfully muted
 - Added modals to communicate why and for how long you were suspended
+- Improved reporting modal
 - Improved Social Menu to show when you cannot talk to a user because they are suspended
 - Improved Terms of Use and Privacy Policy modal design
 

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/impl/basic/impl.kt

@@ -143,6 +143,11 @@ private class Node<T>(
         if (impl !is Node<*>) return getUntracked()
         if (impl.state == NodeState.Dead) return getUntracked()
 
+        // Note: Need to get value before registering the dependent, otherwise if this node is dirty, getUntracked will
+        // re-evaluate it which marks all dependents as dirty, but this new dependent hasn't seen the old value, so it'd
+        // be wrong to mark it as dirty.
+        val value = getUntracked()
+
         val dependency = this
         val dependent = impl
 
@@ -153,7 +158,7 @@ private class Node<T>(
         for (edge in if (listA.size < listB.size) listA else listB) {
             if (edge.dependency == dependency && edge.dependent == dependent) {
                 edge.suspended = false // may need to re-enable the edge if it's currently suspended
-                return getUntracked()
+                return value
             }
         }
 
@@ -166,7 +171,7 @@ private class Node<T>(
         // (this is really fast in when there isn't anything to do thanks to the ReferenceQueue)
         cleanupStaleReferences()
 
-        return getUntracked()
+        return value
     }
 
     override fun getUntracked(): T {
@@ -238,11 +243,15 @@ private class Node<T>(
             }
         }
 
-        if (state == NodeState.Dirty) {
+        val wasDirty = state == NodeState.Dirty
+        state = NodeState.Clean
+
+        if (wasDirty) {
             for (edge in allDependencies) {
                 edge.suspended = true
             }
 
+            // Beware: This invocation may throw an exception if user code is faulty! We should handle that correctly.
             val newValue = func(this)
 
             if (state == NodeState.Dead) {
@@ -266,8 +275,6 @@ private class Node<T>(
                 }
             }
         }
-
-        state = NodeState.Clean
     }
 
     fun cleanup() {
@@ -339,18 +346,32 @@ private class Update {
             return
         }
 
+        var exception: Throwable? = null
+
         processing = true
         try {
             var i = 0
             while (true) {
                 val node = queue.getOrNull(i) ?: break
-                node.update(this)
+                try {
+                    node.update(this)
+                } catch (e: Throwable) {
+                    if (exception == null) {
+                        exception = e
+                    } else {
+                        exception.addSuppressed(e)
+                    }
+                }
                 i++
             }
             queue.clear()
         } finally {
             processing = false
         }
+
+        if (exception != null) {
+            throw exception
+        }
     }
 
     companion object {

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/impl/minimal/impl.kt

@@ -135,6 +135,11 @@ private class Node<T>(
         if (impl !is Node<*>) return getUntracked()
         if (impl.state == NodeState.Dead) return getUntracked()
 
+        // Note: Need to get value before registering the dependent, otherwise if this node is dirty, getUntracked will
+        // re-evaluate it which marks all dependents as dirty, but this new dependent hasn't seen the old value, so it'd
+        // be wrong to mark it as dirty.
+        val value = getUntracked()
+
         val dependency = this
         val dependent = impl
 
@@ -145,7 +150,7 @@ private class Node<T>(
         for (edge in if (listA.size < listB.size) listA else listB) {
             if (edge.dependency == dependency && edge.dependent == dependent) {
                 edge.suspended = false // may need to re-enable the edge if it's currently suspended
-                return getUntracked()
+                return value
             }
         }
 
@@ -158,7 +163,7 @@ private class Node<T>(
         // (this is really fast in when there isn't anything to do thanks to the ReferenceQueue)
         cleanupStaleReferences()
 
-        return getUntracked()
+        return value
     }
 
     override fun getUntracked(): T {
@@ -230,11 +235,15 @@ private class Node<T>(
             }
         }
 
-        if (state == NodeState.Dirty) {
+        val wasDirty = state == NodeState.Dirty
+        state = NodeState.Clean
+
+        if (wasDirty) {
             for (edge in allDependencies) {
                 edge.suspended = true
             }
 
+            // Beware: This invocation may throw an exception if user code is faulty! We should handle that correctly.
             val newValue = func(this)
 
             if (state == NodeState.Dead) {
@@ -258,8 +267,6 @@ private class Node<T>(
                 }
             }
         }
-
-        state = NodeState.Clean
     }
 
     fun cleanup() {
@@ -332,18 +339,32 @@ private class Update {
             return
         }
 
+        var exception: Throwable? = null
+
         processing = true
         try {
             var i = 0
             while (true) {
                 val node = queue.getOrNull(i) ?: break
-                node.update(this)
+                try {
+                    node.update(this)
+                } catch (e: Throwable) {
+                    if (exception == null) {
+                        exception = e
+                    } else {
+                        exception.addSuppressed(e)
+                    }
+                }
                 i++
             }
             queue.clear()
         } finally {
             processing = false
         }
+
+        if (exception != null) {
+            throw exception
+        }
     }
 
     companion object {

elementa/statev2/src/test/kotlin/gg/essential/gui/elementa/state/v2/EffectTest.kt

@@ -12,8 +12,11 @@
 package gg.essential.gui.elementa.state.v2
 
 import gg.essential.elementa.state.v2.ReferenceHolder
+import org.junit.jupiter.api.assertThrows
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.TimeSource
 
@@ -128,6 +131,24 @@ class EffectTest {
         assertEquals(3, ran, "Effect should not have ran, it had been unregistered")
     }
 
+    @Test
+    fun testEffectChangingItsOwnDependencies() {
+        val state = mutableStateOf(1)
+
+        val seenValues = mutableListOf<Int>()
+
+        val unregister = effect(ReferenceHolder.Weak) {
+            val value = state()
+            seenValues.add(value)
+
+            state.set(2)
+        }
+
+        assertEquals(listOf(1, 2), seenValues)
+
+        unregister()
+    }
+
     @Test
     fun testEffectGarbageCollection() {
         val state = mutableStateOf(0)
@@ -167,4 +188,112 @@ class EffectTest {
             }
         }
     }
+
+    @Test
+    fun testEffectThrowingException() {
+        val state = mutableStateOf(0)
+        // We'll also throw in a `memo` to check that its internal state isn't corrupted either
+        val derived = memo { state() }
+
+        class TestException : RuntimeException()
+
+        var assert1: ((Int?) -> Unit)? = { assertEquals(0, it) }
+        var throw1: TestException? = null
+        val unregister1 = effect(ReferenceHolder.Weak) {
+            assert1.let { func ->
+                assertNotNull(func, "Unexpected invocation of first effect!")
+                func(derived())
+            }
+            assert1 = null
+
+            throw1?.let { throw it }
+        }
+
+        var assert2: ((Int?) -> Unit)? = { assertEquals(0, it) }
+        var throw2: TestException? = null
+        val unregister2 = effect(ReferenceHolder.Weak) {
+            assert2.let { func ->
+                assertNotNull(func, "Unexpected invocation of second effect!")
+                func(derived())
+            }
+            assert2 = null
+
+            throw2?.let { throw it }
+        }
+
+        // Ensure setup is correct
+        assert1 = { assertEquals(1, it) }
+        assert2 = { assertEquals(1, it) }
+        state.set(1)
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(1, derived.getUntracked())
+
+        // Have the first effect throw
+        assert1 = { assertEquals(2, it) }
+        assert2 = { assertEquals(2, it) }
+        throw1 = TestException()
+        assertEquals(throw1, assertThrows<TestException> {
+            state.set(2)
+        })
+        throw1 = null
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(2, derived.getUntracked())
+
+        // Ensure future updates are unaffected
+        assert1 = { assertEquals(3, it) }
+        assert2 = { assertEquals(3, it) }
+        state.set(3)
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(3, derived.getUntracked())
+
+        // Have the second effect throw
+        assert1 = { assertEquals(4, it) }
+        assert2 = { assertEquals(4, it) }
+        throw2 = TestException()
+        assertEquals(throw2, assertThrows<TestException> {
+            state.set(4)
+        })
+        throw2 = null
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(4, derived.getUntracked())
+
+        // Ensure future updates are unaffected
+        assert1 = { assertEquals(5, it) }
+        assert2 = { assertEquals(5, it) }
+        state.set(5)
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(5, derived.getUntracked())
+
+        // Have both effects throw
+        assert1 = { assertEquals(6, it) }
+        assert2 = { assertEquals(6, it) }
+        throw1 = TestException()
+        throw2 = TestException()
+        val e = assertThrows<TestException> {
+            state.set(6)
+        }
+        assertEquals(throw1, e)
+        assertEquals(throw2, throw1.suppressedExceptions[0])
+        throw1 = null
+        throw2 = null
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(6, derived.getUntracked())
+
+        // Ensure future updates are unaffected
+        assert1 = { assertEquals(7, it) }
+        assert2 = { assertEquals(7, it) }
+        state.set(7)
+        assertNull(assert1, "First effect was not invoked")
+        assertNull(assert2, "Second effect was not invoked")
+        assertEquals(7, derived.getUntracked())
+
+        unregister1()
+        unregister2()
+    }
 }

features.properties

@@ -1,6 +1,2 @@
 always=true
-server_discovery=true
-updated_gifting_modal=true
-updated_coins_purchase_modal=true
-modal_update=true
 suspensions_and_chat_filtering=true

gradle.properties

@@ -10,4 +10,4 @@ minecraftVersion=11202
 # TODO remove once upgrading to Loom 1.10
 # fabric-api 1.21.5 was built with Loom 1.10, seems to work well enough in dev with our current 1.7 though
 loom.ignoreDependencyLoomVersionValidation=true
-version=1.3.10
+version=1.3.10.1