com.wallstop-studios.unity-helpers 2.0.0-rc57 → 2.0.0-rc59

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -10,6 +10,45 @@
     [Serializable]
     public sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
+        public struct CyclicBufferEnumerator : IEnumerator<T>
+        {
+            private readonly CyclicBuffer<T> _buffer;
+
+            private int _index;
+            private T _current;
+
+            internal CyclicBufferEnumerator(CyclicBuffer<T> buffer)
+            {
+                _buffer = buffer;
+                _index = -1;
+                _current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (++_index < _buffer.Count)
+                {
+                    _current = _buffer._buffer[_buffer.AdjustedIndexFor(_index)];
+                    return true;
+                }
+
+                _current = default;
+                return false;
+            }
+
+            public T Current => _current;
+
+            object IEnumerator.Current => Current;
+
+            public void Reset()
+            {
+                _index = -1;
+                _current = default;
+            }
+
+            public void Dispose() { }
+        }
+
         public int Capacity { get; private set; }
         public int Count { get; private set; }
 
@@ -47,13 +86,14 @@
             }
         }
 
-        public IEnumerator<T> GetEnumerator()
+        public CyclicBufferEnumerator GetEnumerator()
         {
-            for (int i = 0; i < Count; ++i)
-            {
-                // No need for bound check, we're safe
-                yield return _buffer[AdjustedIndexFor(i)];
-            }
+            return new CyclicBufferEnumerator(this);
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            return GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()

package/Runtime/Core/Extension/IListExtensions.cs

@@ -4,6 +4,7 @@
     using System.Collections.Generic;
     using Helper;
     using Random;
+    using Utils;
 
     public static class IListExtensions
     {
@@ -30,12 +31,12 @@
 
         public static void Shift<T>(this IList<T> list, int amount)
         {
-            int count = list.Count;
-            if (count <= 1)
+            if (list is not { Count: > 1 })
             {
                 return;
             }
 
+            int count = list.Count;
             amount = amount.PositiveMod(count);
             if (amount == 0)
             {
@@ -87,14 +88,14 @@
         }
 
         public static void InsertionSort<T, TComparer>(this IList<T> array, TComparer comparer)
-            where TComparer : struct, IComparer<T>
+            where TComparer : IComparer<T>
         {
             int arrayCount = array.Count;
             for (int i = 1; i < arrayCount; ++i)
             {
                 T key = array[i];
                 int j = i - 1;
-                while (j >= 0 && comparer.Compare(array[j], key) > 0)
+                while (0 <= j && 0 < comparer.Compare(array[j], key))
                 {
                     array[j + 1] = array[j];
                     j--;
@@ -102,5 +103,44 @@
                 array[j + 1] = key;
             }
         }
+
+        public static void SortByName<T>(this IList<T> inputList)
+            where T : UnityEngine.Object
+        {
+            switch (inputList)
+            {
+                case T[] array:
+                    Array.Sort(array, UnityObjectNameComparer<T>.Instance);
+                    return;
+                case List<T> list:
+                    list.Sort(UnityObjectNameComparer<T>.Instance);
+                    return;
+                default:
+                    inputList.InsertionSort(UnityObjectNameComparer<T>.Instance);
+                    break;
+            }
+        }
+
+        public static bool IsSorted<T>(this IList<T> list, IComparer<T> comparer = null)
+        {
+            if (list.Count <= 1)
+            {
+                return true;
+            }
+
+            comparer ??= Comparer<T>.Default;
+
+            T previous = list[0];
+            for (int i = 1; i < list.Count; ++i)
+            {
+                T current = list[i];
+                if (comparer.Compare(previous, current) > 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

package/Runtime/Core/Extension/StringExtensions.cs

@@ -2,10 +2,15 @@
 {
     using System.Collections.Generic;
     using System.Text;
+    using System.Threading;
     using Serialization;
 
     public static class StringExtensions
     {
+        private static ThreadLocal<StringBuilder> StringBuilderCache = new(
+            () => new StringBuilder()
+        );
+
         private static readonly HashSet<char> PascalCaseSeparators = new()
         {
             '_',
@@ -46,7 +51,8 @@
         public static string ToPascalCase(this string value, string separator = "")
         {
             int startIndex = 0;
-            StringBuilder stringBuilder = new();
+            StringBuilder stringBuilder = StringBuilderCache.Value;
+            stringBuilder.Clear();
             bool appendedAnySeparator = false;
             for (int i = 0; i < value.Length; ++i)
             {
@@ -147,5 +153,28 @@
 
             return stringBuilder.ToString();
         }
+
+        public static bool NeedsLowerInvariantConversion(this string input)
+        {
+            foreach (char inputCharacter in input)
+            {
+                if (char.ToLowerInvariant(inputCharacter) != inputCharacter)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static bool NeedsTrim(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            return char.IsWhiteSpace(input[0]) || char.IsWhiteSpace(input[^1]);
+        }
     }
 }

package/Runtime/Core/Helper/DirectoryHelper.cs

@@ -0,0 +1,132 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+    using UnityEngine;
+
+    public static class DirectoryHelper
+    {
+        public static string GetCallerScriptDirectory([CallerFilePath] string sourceFilePath = "")
+        {
+            return string.IsNullOrWhiteSpace(sourceFilePath)
+                ? string.Empty
+                : Path.GetDirectoryName(sourceFilePath);
+        }
+
+        public static string FindPackageRootPath(string startDirectory)
+        {
+            return FindRootPath(
+                startDirectory,
+                path => File.Exists(Path.Combine(path, "package.json"))
+            );
+        }
+
+        public static string FindRootPath(
+            string startDirectory,
+            Func<string, bool> terminalCondition
+        )
+        {
+            string currentPath = startDirectory;
+            while (!string.IsNullOrWhiteSpace(currentPath))
+            {
+                try
+                {
+                    if (terminalCondition(currentPath))
+                    {
+                        DirectoryInfo directoryInfo = new(currentPath);
+                        if (!directoryInfo.Exists)
+                        {
+                            return currentPath;
+                        }
+
+                        return directoryInfo.FullName;
+                    }
+                }
+                catch
+                {
+                    return currentPath;
+                }
+
+                try
+                {
+                    string parentPath = Path.GetDirectoryName(currentPath);
+                    if (string.Equals(parentPath, currentPath, StringComparison.OrdinalIgnoreCase))
+                    {
+                        break;
+                    }
+
+                    currentPath = parentPath;
+                }
+                catch
+                {
+                    return currentPath;
+                }
+            }
+
+            return string.Empty;
+        }
+
+        public static string FindAbsolutePathToDirectory(string directory)
+        {
+            string scriptDirectory = GetCallerScriptDirectory();
+            if (string.IsNullOrEmpty(scriptDirectory))
+            {
+                return string.Empty;
+            }
+
+            string packageRootAbsolute = FindPackageRootPath(scriptDirectory);
+            if (string.IsNullOrEmpty(packageRootAbsolute))
+            {
+                return string.Empty;
+            }
+
+            string targetPathAbsolute = Path.Combine(
+                packageRootAbsolute,
+                directory.Replace('/', Path.DirectorySeparatorChar)
+            );
+
+            return AbsoluteToUnityRelativePath(targetPathAbsolute);
+        }
+
+        public static string AbsoluteToUnityRelativePath(string absolutePath)
+        {
+            if (string.IsNullOrWhiteSpace(absolutePath))
+            {
+                return string.Empty;
+            }
+
+            absolutePath = absolutePath.Replace('\\', '/');
+            string projectRoot = Application.dataPath.Replace('\\', '/');
+
+            projectRoot = Path.GetDirectoryName(projectRoot)?.Replace('\\', '/');
+            if (string.IsNullOrWhiteSpace(projectRoot))
+            {
+                return string.Empty;
+            }
+
+            if (absolutePath.StartsWith(projectRoot, StringComparison.OrdinalIgnoreCase))
+            {
+                // +1 to remove the leading slash only if projectRoot doesn't end with one
+                int startIndex = projectRoot.EndsWith("/", StringComparison.OrdinalIgnoreCase)
+                    ? projectRoot.Length
+                    : projectRoot.Length + 1;
+                return absolutePath.Length > startIndex ? absolutePath[startIndex..] : string.Empty;
+            }
+            if (absolutePath.StartsWith(projectRoot, StringComparison.OrdinalIgnoreCase))
+            {
+                int startIndex = projectRoot.EndsWith("/", StringComparison.OrdinalIgnoreCase)
+                    ? projectRoot.Length
+                    : projectRoot.Length + 1;
+                if (startIndex < absolutePath.Length)
+                {
+                    return "Assets/" + absolutePath[startIndex..];
+                }
+
+                return "Assets";
+            }
+
+            return string.Empty;
+        }
+    }
+}

package/Runtime/Core/Helper/DirectoryHelper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aefe35fe27e449f2b56e61a24c16cf62
+timeCreated: 1744994158

package/Runtime/Core/Helper/Partials/ObjectHelpers.cs

@@ -365,7 +365,7 @@
 
                 if (content == null)
                 {
-                    Debug.LogError($"Unable to load {prefab} as a prefab");
+                    Debug.LogError($"Unable to load {prefab} as a prefab", prefab);
                     return;
                 }
 

package/Runtime/Core/Helper/SceneHelper.cs

@@ -103,11 +103,7 @@
             }
         }
 
-        public
-#if UNITY_EDITOR
-        readonly
-#endif
-        struct SceneLoadScope
+        public sealed class SceneLoadScope
         {
             private
 #if UNITY_EDITOR

package/Runtime/Utils/StartTracker.cs

@@ -0,0 +1,15 @@
+namespace UnityHelpers.Utils
+{
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class StartTracker : MonoBehaviour
+    {
+        public bool Started { get; private set; }
+
+        private void Start()
+        {
+            Started = true;
+        }
+    }
+}

package/Runtime/Utils/StartTracker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a3a542214e594fd199901492cbaaceac
+timeCreated: 1744835337

package/Runtime/Utils/UnityObjectNameComparer.cs

@@ -0,0 +1,33 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+
+    public sealed class UnityObjectNameComparer<T> : IComparer<T>
+        where T : UnityEngine.Object
+    {
+        public static readonly UnityObjectNameComparer<T> Instance = new();
+
+        private UnityObjectNameComparer() { }
+
+        public int Compare(T x, T y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+
+            if (y == null)
+            {
+                return 1;
+            }
+
+            if (x == null)
+            {
+                return -1;
+            }
+
+            return string.Compare(x.name, y.name, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

package/Runtime/Utils/UnityObjectNameComparer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 24d2fd0003b641b7be52bc54e743be35
+timeCreated: 1744989641

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc57",
+  "version": "2.0.0-rc59",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},