Version 1.3.9.3

Author: EssentialGGBot

changelog/release-1.3.9.3.md

@@ -0,0 +1,12 @@
+Title: Bug Patch
+Summary: Minor bug fixes
+
+## New Versions
+- Added support for 1.21.10 Fabric
+
+## Bug Fixes
+- Fixed buttons in Multiplayer menu not moving when the game window is resized on 1.21.9+
+- Fixed incorrect scrolling when cosmetic is clicked on preview player in Wardrobe
+- Fixed incorrect sub-category being highlighted in Wardrobe
+- Fixed Numpad Enter key not being recognized as Enter key
+- Fixed equipped cape disappearing when Essential is disabled

elementa/layoutdsl/src/main/kotlin/gg/essential/gui/common/stateExtensions.kt

@@ -14,10 +14,12 @@ package gg.essential.gui.common
 import gg.essential.elementa.state.State
 import gg.essential.elementa.state.v2.ReferenceHolder
 
+@Deprecated("Use StateV2 instead")
 fun <T> State<T>.onSetValueAndNow(listener: (T) -> Unit) = onSetValue(listener).also { listener(get()) }
 
 @Deprecated("See `State.onSetValue`. Use `stateBy`/`effect` instead.")
 fun <T> gg.essential.gui.elementa.state.v2.State<T>.onSetValueAndNow(owner: ReferenceHolder, listener: (T) -> Unit) =
     onSetValue(owner, listener).also { listener(get()) }
 
+@Deprecated("Use StateV2 instead")
 operator fun State<Boolean>.not() = map { !it }

elementa/layoutdsl/src/main/kotlin/gg/essential/gui/util/elementaExtensions.kt

@@ -35,12 +35,20 @@ inline fun <reified T : Effect> UIComponent.get() =
 inline fun <reified T : Effect> UIComponent.getOrPut(init: () -> T) =
     get<T>() ?: init().also { enableEffect(it) }
 
+@Deprecated("Use StateV2 instead", ReplaceWith("pollingStateV2(initialValue, getter)"))
 fun <T> UIComponent.pollingState(initialValue: T? = null, getter: () -> T): State<T> {
     val state = BasicState(initialValue ?: getter())
     addUpdateFunc { _, _ -> state.set(getter()) }
     return state
 }
 
+/**
+ * Turns some impure computation into a pure [StateV2] by evaluating it before every frame.
+ *
+ * This should be avoided in favor of pure State-based computations where possible, but may be necessary when
+ * interfacing with third-party code.
+ * If the impure part of your computation is the current time, [Observer.systemTime] can likely replace this method.
+ */
 fun <T> UIComponent.pollingStateV2(initialValue: T? = null, getter: () -> T): StateV2<T> {
     val state = mutableStateOf(initialValue ?: getter())
     addUpdateFunc { _, _ -> state.set(getter()) }
@@ -224,6 +232,7 @@ fun UIComponent.hoverScopeV2(parentOnly: Boolean = false): StateV2<Boolean> {
     return consumer.state
 }
 
+@Deprecated("Use StateV2 instead", ReplaceWith("hoverScopeV2(parentOnly)"))
 fun UIComponent.hoverScope(parentOnly: Boolean = false): State<Boolean> =
     hoverScopeV2(parentOnly).toV1(this)
 
@@ -360,6 +369,7 @@ fun UIComponent.isComponentInParentChain(target: UIComponent): Boolean {
 fun UIComponent.isInComponentTree(): Boolean =
     this is Window || hasParent && this in parent.children && parent.isInComponentTree()
 
+@Deprecated("ObservableList should be replaced with StateV2's `ListState`")
 fun <E> ObservableList<E>.onItemRemoved(callback: (E) -> Unit) {
     addObserver { _, arg ->
         if (arg is ObservableRemoveEvent<*>) {
@@ -368,6 +378,7 @@ fun <E> ObservableList<E>.onItemRemoved(callback: (E) -> Unit) {
     }
 }
 
+@Deprecated("ObservableList should be replaced with StateV2's `ListState`")
 fun <E> ObservableList<E>.onItemAdded(callback: (E) -> Unit) {
     addObserver { _, arg ->
         if (arg is ObservableAddEvent<*>) {
@@ -376,6 +387,7 @@ fun <E> ObservableList<E>.onItemAdded(callback: (E) -> Unit) {
     }
 }
 
+@Deprecated("ObservableList should be replaced with StateV2's `ListState`")
 @Suppress("UNCHECKED_CAST")
 fun <E> ObservableList<E>.toStateV2List(): ListStateV2<E> {
     val stateList = mutableStateOf(MutableTrackedList(this.toMutableList()))

elementa/layoutdsl/src/main/kotlin/gg/essential/gui/util/focusable.kt

@@ -67,7 +67,7 @@ private fun UIComponent.setupKeyboardNavigation(): UIComponent.(Char, Int) -> Un
         }
 
         when (keyCode) {
-            UKeyboard.KEY_ENTER -> simulateLeftClick()
+            UKeyboard.KEY_ENTER, UKeyboard.KEY_NUMPADENTER -> simulateLeftClick()
             UKeyboard.KEY_TAB -> passFocusToNextComponent(backwards = UKeyboard.isShiftKeyDown())
         }
     }

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/combinators/booleans.kt

@@ -14,12 +14,26 @@ package gg.essential.gui.elementa.state.v2.combinators
 import gg.essential.gui.elementa.state.v2.MutableState
 import gg.essential.gui.elementa.state.v2.State
 
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { this() && other() }"))
+@Suppress("DEPRECATION")
 infix fun State<Boolean>.and(other: State<Boolean>) =
     zip(other) { a, b -> a && b }
 
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { this() || other() }"))
+@Suppress("DEPRECATION")
 infix fun State<Boolean>.or(other: State<Boolean>) =
     zip(other) { a, b -> a || b }
 
-operator fun State<Boolean>.not() = map { !it }
+/**
+ * Creates a new [State] which has the inverse value of this [State].
+ *
+ * This is mostly a convenience method so one can write `if_(!myState) {` instead of the more verbose
+ * `if_({ !myState() }) {`. Both are equivalent.
+ * This method shouldn't be overused though. If the expression is more complex, the verbose version is usually
+ * preferred because it generalizes much better.
+ */
+operator fun State<Boolean>.not() = letState { !it }
 
-operator fun MutableState<Boolean>.not() = bimap({ !it }, { !it })
+operator fun MutableState<Boolean>.not() = bimapState({ !it }, { !it })

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

@@ -12,27 +12,72 @@
 package gg.essential.gui.elementa.state.v2.combinators
 
 import gg.essential.gui.elementa.state.v2.MutableState
+import gg.essential.gui.elementa.state.v2.Observer
 import gg.essential.gui.elementa.state.v2.State
 import gg.essential.gui.elementa.state.v2.memo
 
 /** Maps this state into a new state */
+@Deprecated("This method always applies `memo` even though it is often unnecessary. " +
+        "Use `letState` instead, and explicitly call `.memo()` on the result only where required.")
 fun <T, U> State<T>.map(mapper: (T) -> U): State<U> {
     return memo { mapper(get()) }
 }
 
+/**
+ * Derives a new [State] from this [State].
+ *
+ * This method is equivalent to `.let { state -> State { block(state()) } }`.
+ *
+ * Note: For repeated or more complex derivations, an explicit [State] or [memo] lambda is likely easier to use.
+ */
+inline fun <T, U> State<T>.letState(crossinline block: Observer.(T) -> U): State<U> {
+    val sourceState = this
+    return State { block(sourceState()) }
+}
+
 /** Maps this mutable state into a new mutable state. */
+@Deprecated("This method always applies `memo` even though it is often unnecessary. " +
+        "Use `bimapState` or `bimapMemo` instead.")
 fun <T, U> MutableState<T>.bimap(map: (T) -> U, unmap: (U) -> T): MutableState<U> {
-    return object : MutableState<U>, State<U> by this.map(map) {
+    return bimapMemo(map, unmap)
+}
+
+/**
+ * Derives a new [MutableState] from this [MutableState].
+ *
+ * This variant uses [memo] internally. If this is not required, use [bimapState] instead.
+ */
+fun <T, U> MutableState<T>.bimapMemo(map: (T) -> U, unmap: (U) -> T): MutableState<U> {
+    val sourceState = this
+    return object : MutableState<U>, State<U> by (memo { map(sourceState()) }) {
         override fun set(mapper: (U) -> U) {
-            this@bimap.set { unmap(mapper(map(it))) }
+            sourceState.set { unmap(mapper(map(it))) }
         }
     }
 }
 
+/**
+ * Derives a new [MutableState] from this [MutableState].
+ *
+ * @see [bimapMemo]
+ */
+fun <T, U> MutableState<T>.bimapState(map: (T) -> U, unmap: (U) -> T): MutableState<U> {
+    val sourceState = this
+    return object : MutableState<U> {
+        override fun Observer.get(): U = map(sourceState())
+        override fun set(mapper: (U) -> U) = sourceState.set { unmap(mapper(map(it))) }
+    }
+}
+
 /** Zips this state with another state */
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { Pair(this(), other()) }"))
+@Suppress("DEPRECATION")
 fun <T, U> State<T>.zip(other: State<U>): State<Pair<T, U>> = zip(other, ::Pair)
 
 /** Zips this state with another state using [mapper] */
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { mapper(this(), other()) }"))
 fun <T, U, V> State<T>.zip(other: State<U>, mapper: (T, U) -> V): State<V> {
     return memo { mapper(this@zip(), other()) }
 }

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/combinators/strings.kt

@@ -13,9 +13,18 @@ package gg.essential.gui.elementa.state.v2.combinators
 
 import gg.essential.gui.elementa.state.v2.State
 
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { this().contains(other(), ignoreCase = ignoreCase) }"))
+@Suppress("DEPRECATION")
 fun State<String>.contains(other: State<String>, ignoreCase: Boolean = false) =
     zip(other) { a, b -> a.contains(b, ignoreCase) }
 
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { this().isEmpty() }"))
+@Suppress("DEPRECATION")
 fun State<String>.isEmpty() = map { it.isEmpty() }
 
+@Deprecated("Exists primarily for easier migration from State v1. Prefer using [State] lambda (with `memo` where necessary) instead.",
+    replaceWith = ReplaceWith("State { this().isNotEmpty() }"))
+@Suppress("DEPRECATION")
 fun State<String>.isNotEmpty() = map { it.isNotEmpty() }

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/combinators/utils.kt

@@ -14,4 +14,4 @@ package gg.essential.gui.elementa.state.v2.combinators
 import gg.essential.gui.elementa.state.v2.MutableState
 
 fun MutableState<Int>.reorder(vararg mapping: Int) =
-    bimap({ mapping[it] }, { mapping.indexOf(it) })
+    bimapState({ mapping[it] }, { mapping.indexOf(it) })

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

@@ -25,13 +25,15 @@ internal interface Impl {
     fun <T> memo(func: Observer.() -> T): State<T>
     fun effect(referenceHolder: ReferenceHolder, func: Observer.() -> Unit): () -> Unit
 
+    @Suppress("DEPRECATION")
     fun <T> stateDelegatingTo(state: State<T>): DelegatingState<T> =
         object : DelegatingState<T> {
             private val target = mutableStateOf(state)
             override fun rebind(newState: State<T>) = target.set(newState)
             override fun Observer.get(): T = target()()
         }
 
+    @Suppress("DEPRECATION")
     fun <T> mutableStateDelegatingTo(state: MutableState<T>): DelegatingMutableState<T> =
         object : DelegatingMutableState<T> {
             private val target = mutableStateOf(state)