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

package/Runtime/Core/Helper/ArrayConverter.cs

@@ -1,39 +1,39 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-
-    public static class ArrayConverter
-    {
-        public static byte[] IntArrayToByteArrayBlockCopy(int[] ints)
-        {
-            if (ints == null)
-            {
-                throw new ArgumentNullException(nameof(ints));
-            }
-
-            byte[] bytes = new byte[ints.Length * sizeof(int)];
-            Buffer.BlockCopy(ints, 0, bytes, 0, bytes.Length);
-            return bytes;
-        }
-
-        public static int[] ByteArrayToIntArrayBlockCopy(byte[] bytes)
-        {
-            if (bytes == null)
-            {
-                throw new ArgumentNullException(nameof(bytes), "Byte array cannot be null.");
-            }
-
-            if (bytes.Length % sizeof(int) != 0)
-            {
-                throw new ArgumentException(
-                    $"Byte array length must be a multiple of {sizeof(int)}.",
-                    nameof(bytes)
-                );
-            }
-
-            int[] ints = new int[bytes.Length / sizeof(int)];
-            Buffer.BlockCopy(bytes, 0, ints, 0, bytes.Length);
-            return ints;
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+
+    public static class ArrayConverter
+    {
+        public static byte[] IntArrayToByteArrayBlockCopy(int[] ints)
+        {
+            if (ints == null)
+            {
+                throw new ArgumentNullException(nameof(ints));
+            }
+
+            byte[] bytes = new byte[ints.Length * sizeof(int)];
+            Buffer.BlockCopy(ints, 0, bytes, 0, bytes.Length);
+            return bytes;
+        }
+
+        public static int[] ByteArrayToIntArrayBlockCopy(byte[] bytes)
+        {
+            if (bytes == null)
+            {
+                throw new ArgumentNullException(nameof(bytes), "Byte array cannot be null.");
+            }
+
+            if (bytes.Length % sizeof(int) != 0)
+            {
+                throw new ArgumentException(
+                    $"Byte array length must be a multiple of {sizeof(int)}.",
+                    nameof(bytes)
+                );
+            }
+
+            int[] ints = new int[bytes.Length / sizeof(int)];
+            Buffer.BlockCopy(bytes, 0, ints, 0, bytes.Length);
+            return ints;
+        }
+    }
+}

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

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: fa2c6f423a9448a59a9d243b1833d88d
+fileFormatVersion: 2
+guid: fa2c6f423a9448a59a9d243b1833d88d
 timeCreated: 1732491761

package/Runtime/Core/Helper/AssignUtilities.cs

@@ -1,14 +1,14 @@
-namespace UnityHelpers.Core.Helper
-{
-    public static class AssignUtilities
-    {
-        // Exchanges the assignTo to have the value of assignFrom.
-        // Returns the old value of AssignTo.
-        public static T Exchange<T>(ref T assignTo, T assignFrom)
-        {
-            T oldValue = assignTo;
-            assignTo = assignFrom;
-            return oldValue;
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    public static class AssignUtilities
+    {
+        // Exchanges the assignTo to have the value of assignFrom.
+        // Returns the old value of AssignTo.
+        public static T Exchange<T>(ref T assignTo, T assignFrom)
+        {
+            T oldValue = assignTo;
+            assignTo = assignFrom;
+            return oldValue;
+        }
+    }
+}

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

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 29464873736a45fc8db9b5241457e65e
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 29464873736a45fc8db9b5241457e65e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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/Enumerables.cs

@@ -1,17 +1,17 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System.Collections.Generic;
-
-    public static class Enumerables
-    {
-        public static IEnumerable<T> Of<T>(T element)
-        {
-            return new[] { element };
-        }
-
-        public static IEnumerable<T> Of<T>(params T[] elements)
-        {
-            return elements;
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System.Collections.Generic;
+
+    public static class Enumerables
+    {
+        public static IEnumerable<T> Of<T>(T element)
+        {
+            return new[] { element };
+        }
+
+        public static IEnumerable<T> Of<T>(params T[] elements)
+        {
+            return elements;
+        }
+    }
+}

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -1,32 +1,32 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-
-    public static class FormattingHelpers
-    {
-        private static readonly string[] ByteSizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
-
-        public static string FormatBytes(long bytes)
-        {
-            bytes = Math.Max(0L, bytes);
-            double len = bytes;
-            int order = 0;
-
-            const int byteInChunk = 1024;
-            while (byteInChunk <= len)
-            {
-                len /= byteInChunk;
-                if (order < ByteSizes.Length - 1)
-                {
-                    ++order;
-                }
-                else
-                {
-                    throw new ArgumentException($"Too many bytes! Cannot parse {bytes}");
-                }
-            }
-
-            return $"{len:0.##} {ByteSizes[order]}";
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+
+    public static class FormattingHelpers
+    {
+        private static readonly string[] ByteSizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+
+        public static string FormatBytes(long bytes)
+        {
+            bytes = Math.Max(0L, bytes);
+            double len = bytes;
+            int order = 0;
+
+            const int byteInChunk = 1024;
+            while (byteInChunk <= len)
+            {
+                len /= byteInChunk;
+                if (order < ByteSizes.Length - 1)
+                {
+                    ++order;
+                }
+                else
+                {
+                    throw new ArgumentException($"Too many bytes! Cannot parse {bytes}");
+                }
+            }
+
+            return $"{len:0.##} {ByteSizes[order]}";
+        }
+    }
+}

package/Runtime/Core/Helper/Geometry.cs

@@ -1,43 +1,43 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System.Collections.Generic;
-    using System.Linq;
-    using UnityEngine;
-
-    public static class Geometry
-    {
-        public static Rect Accumulate(this IEnumerable<Rect> rects)
-        {
-            return rects.Aggregate(
-                (accumulated, next) =>
-                    new Rect(
-                        Mathf.Min(accumulated.xMin, next.xMin),
-                        Mathf.Min(accumulated.yMin, next.yMin),
-                        Mathf.Max(accumulated.xMax, next.xMax)
-                            - Mathf.Min(accumulated.xMin, next.xMin),
-                        Mathf.Max(accumulated.yMax, next.yMax)
-                            - Mathf.Min(accumulated.yMin, next.yMin)
-                    )
-            );
-        }
-
-        //Where is p in relation to a-b
-        // < 0 -> to the right
-        // = 0 -> on the line
-        // > 0 -> to the left
-        public static float IsAPointLeftOfVectorOrOnTheLine(Vector2 a, Vector2 b, Vector2 p)
-        {
-            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
-        }
-
-        public static float IsAPointLeftOfVectorOrOnTheLine(Vector3 a, Vector3 b, Vector3 p)
-        {
-            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
-        }
-
-        public static int IsAPointLeftOfVectorOrOnTheLine(Vector2Int a, Vector2Int b, Vector2Int p)
-        {
-            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using UnityEngine;
+
+    public static class Geometry
+    {
+        public static Rect Accumulate(this IEnumerable<Rect> rects)
+        {
+            return rects.Aggregate(
+                (accumulated, next) =>
+                    new Rect(
+                        Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Min(accumulated.yMin, next.yMin),
+                        Mathf.Max(accumulated.xMax, next.xMax)
+                            - Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Max(accumulated.yMax, next.yMax)
+                            - Mathf.Min(accumulated.yMin, next.yMin)
+                    )
+            );
+        }
+
+        //Where is p in relation to a-b
+        // < 0 -> to the right
+        // = 0 -> on the line
+        // > 0 -> to the left
+        public static float IsAPointLeftOfVectorOrOnTheLine(Vector2 a, Vector2 b, Vector2 p)
+        {
+            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
+        }
+
+        public static float IsAPointLeftOfVectorOrOnTheLine(Vector3 a, Vector3 b, Vector3 p)
+        {
+            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
+        }
+
+        public static int IsAPointLeftOfVectorOrOnTheLine(Vector2Int a, Vector2Int b, Vector2Int p)
+        {
+            return (a.x - p.x) * (b.y - p.y) - (a.y - p.y) * (b.x - p.x);
+        }
+    }
+}