com.wallstop-studios.dxmessaging 2.0.0 → 2.1.1

package/Tests/Runtime/Integrations/Reflex/ReflexIntegrationTests.cs

@@ -0,0 +1,162 @@
+namespace DxMessaging.Tests.Runtime.Reflex
+{
+#if REFLEX_PRESENT
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using DxMessaging.Unity;
+    using DxMessaging.Unity.Integrations.Reflex;
+    using global::Reflex.Core;
+    using global::Reflex.Injectors;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class ReflexIntegrationTests : UnityFixtureBase
+    {
+        [Test]
+        public void InstallerRegistersMessageBusAndConfiguratorAppliesIt()
+        {
+            ContainerBuilder builder = new();
+            DxMessagingInstaller installer = new();
+            installer.InstallBindings(builder);
+
+            Container container = TrackDisposable(builder.Build());
+            IMessageBus bus = container.Resolve<IMessageBus>();
+            Assert.NotNull(bus, "Reflex installer should bind IMessageBus.");
+
+            GameObject go = Track(
+                new GameObject(
+                    nameof(InstallerRegistersMessageBusAndConfiguratorAppliesIt),
+                    typeof(MessagingComponent),
+                    typeof(ReflexConfiguredListener)
+                )
+            );
+
+            ReflexConfiguredListener listener = go.GetComponent<ReflexConfiguredListener>();
+            AttributeInjector.Inject(listener, container);
+            listener.Initialize(bus);
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(bus);
+
+            Assert.AreEqual(
+                1,
+                listener.ReceivedCount,
+                "Listener should observe messages emitted through the Reflex container's bus."
+            );
+        }
+
+        [Test]
+        public void RegistrationInstallerBindsBuilderAgainstContainerBus()
+        {
+            ContainerBuilder builder = new();
+            DxMessagingInstaller coreInstaller = new();
+            coreInstaller.InstallBindings(builder);
+
+            builder.AddSingleton(
+                typeof(StaticMessageBusProvider),
+                typeof(StaticMessageBusProvider),
+                typeof(IMessageBusProvider)
+            );
+
+            DxMessagingRegistrationInstaller registrationInstaller = new();
+            registrationInstaller.InstallBindings(builder);
+
+            Container container = TrackDisposable(builder.Build());
+
+            StaticMessageBusProvider provider = container.Resolve<StaticMessageBusProvider>();
+
+            IMessageRegistrationBuilder registrationBuilder =
+                container.Resolve<IMessageRegistrationBuilder>();
+            using MessageRegistrationLease lease = registrationBuilder.Build(
+                new MessageRegistrationBuildOptions()
+            );
+
+            Assert.AreSame(
+                provider.Bus,
+                lease.MessageBus,
+                "Reflex registration installer should prefer the registered IMessageBusProvider."
+            );
+        }
+
+        [Test]
+        public void RegistrationInstallerExposesConcreteBuilder()
+        {
+            ContainerBuilder builder = new();
+            DxMessagingInstaller coreInstaller = new();
+            coreInstaller.InstallBindings(builder);
+
+            DxMessagingRegistrationInstaller registrationInstaller = new();
+            registrationInstaller.InstallBindings(builder);
+
+            Container container = TrackDisposable(builder.Build());
+
+            var concrete =
+                container.Resolve<DxMessagingRegistrationInstaller.ContainerMessageRegistrationBuilder>();
+            Assert.IsNotNull(
+                concrete,
+                "Container should resolve the concrete registration builder type."
+            );
+
+            IMessageRegistrationBuilder builderInterface =
+                container.Resolve<IMessageRegistrationBuilder>();
+            Assert.IsTrue(
+                ReferenceEquals(concrete, builderInterface),
+                "Container should return the same instance for concrete and interface resolutions."
+            );
+        }
+
+        private sealed class DxMessagingInstaller : IInstaller
+        {
+            public void InstallBindings(ContainerBuilder containerBuilder)
+            {
+                containerBuilder.AddSingleton(
+                    typeof(MessageBus),
+                    typeof(MessageBus),
+                    typeof(IMessageBus)
+                );
+            }
+        }
+
+        private sealed class ReflexConfiguredListener : MonoBehaviour
+        {
+            private IMessageBus _messageBus;
+            private MessageRegistrationToken _token;
+
+            internal int ReceivedCount { get; private set; }
+
+            internal void Initialize(IMessageBus messageBus)
+            {
+                _messageBus = messageBus;
+                MessagingComponent messagingComponent = GetComponent<MessagingComponent>();
+                messagingComponent.Configure(_messageBus, MessageBusRebindMode.RebindActive);
+
+                _token = messagingComponent.Create(this);
+                _ = _token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++ReceivedCount);
+                _token.Enable();
+            }
+
+            private void OnDestroy()
+            {
+                _token?.Disable();
+                _token = null;
+                _messageBus = null;
+            }
+        }
+
+        private sealed class StaticMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus = new MessageBus();
+
+            public IMessageBus Bus => _bus;
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+    }
+#endif
+}

package/Tests/Runtime/Integrations/Reflex/ReflexIntegrationTests.cs.meta

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

package/Tests/Runtime/Integrations/Reflex/Resources/ReflexSettings.asset

@@ -0,0 +1,16 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f50e4916e4924f2788a73057a16764c0, type: 3}
+  m_Name: ReflexSettings
+  m_EditorClassIdentifier: 
+  <LogLevel>k__BackingField: 0
+  <ProjectScopes>k__BackingField: []

package/Tests/Runtime/Integrations/Reflex/Resources/ReflexSettings.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 30c811c802a94b5da26f5961a509179b
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/Reflex/Resources.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5d1779047c8d408693a711f35e4b7812
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/Reflex/WallstopStudios.DxMessaging.Tests.Runtime.Reflex.asmdef

@@ -0,0 +1,27 @@
+{
+  "name": "WallstopStudios.DxMessaging.Tests.Runtime.Reflex",
+  "rootNamespace": "DxMessaging.Tests.Runtime.Reflex",
+  "references": [
+    "UnityEngine.TestRunner",
+    "UnityEditor.TestRunner",
+    "WallstopStudios.DxMessaging",
+    "WallstopStudios.DxMessaging.Tests.Runtime",
+    "Reflex",
+    "WallstopStudios.DxMessaging.Reflex"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": true,
+  "precompiledReferences": ["nunit.framework.dll"],
+  "autoReferenced": true,
+  "defineConstraints": ["UNITY_INCLUDE_TESTS", "REFLEX_PRESENT"],
+  "versionDefines": [
+    {
+      "name": "com.gustavopsantos.reflex",
+      "expression": "0.0.1",
+      "define": "REFLEX_PRESENT"
+    }
+  ],
+  "noEngineReferences": false
+}

package/Tests/Runtime/Integrations/Reflex/WallstopStudios.DxMessaging.Tests.Runtime.Reflex.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cc7a6eb5360b4f5c896d3b54cfc07738
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/Reflex.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9326a2dd5b2745bcaef12640add3525a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/VContainer/VContainerIntegrationTests.cs

@@ -0,0 +1,140 @@
+namespace DxMessaging.Tests.Runtime.VContainer
+{
+#if VCONTAINER_PRESENT
+    using System;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using DxMessaging.Unity;
+    using DxMessaging.Unity.Integrations.VContainer;
+    using global::VContainer;
+    using global::VContainer.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class VContainerIntegrationTests : UnityFixtureBase
+    {
+        [Test]
+        public void ContainerInjectsMessagingComponentWithCustomBus()
+        {
+            ContainerBuilder builder = new();
+            builder.Register<MessageBus>(Lifetime.Singleton).As<IMessageBus>();
+
+            IObjectResolver resolver = TrackDisposable(builder.Build());
+            IMessageBus bus = resolver.Resolve<IMessageBus>();
+            Assert.NotNull(bus);
+
+            GameObject go = Track(
+                new GameObject(
+                    nameof(ContainerInjectsMessagingComponentWithCustomBus),
+                    typeof(MessagingComponent),
+                    typeof(VContainerConfiguredListener)
+                )
+            );
+
+            resolver.InjectGameObject(go);
+            VContainerConfiguredListener listener = go.GetComponent<VContainerConfiguredListener>();
+            listener.Initialize(bus);
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(bus);
+
+            Assert.AreEqual(
+                1,
+                listener.ReceivedCount,
+                "Listener should receive messages emitted via the VContainer-resolved bus."
+            );
+        }
+
+        [Test]
+        public void RegistrationExtensionsExposeBuilder()
+        {
+            ContainerBuilder builder = new();
+            builder.Register<MessageBus>(Lifetime.Singleton).As<IMessageBus>();
+            builder.RegisterMessageRegistrationBuilder();
+
+            IObjectResolver resolver = TrackDisposable(builder.Build());
+            IMessageRegistrationBuilder registrationBuilder =
+                resolver.Resolve<IMessageRegistrationBuilder>();
+            using MessageRegistrationLease lease = registrationBuilder.Build(
+                new MessageRegistrationBuildOptions()
+            );
+
+            Assert.AreSame(
+                resolver.Resolve<IMessageBus>(),
+                lease.MessageBus,
+                "Registration extension should resolve a builder backed by the container bus."
+            );
+        }
+
+        [Test]
+        public void RegistrationExtensionsPreferResolvedProvider()
+        {
+            ContainerBuilder builder = new();
+            builder.Register<MessageBus>(Lifetime.Singleton).As<IMessageBus>();
+
+            MessageBus providerBus = new MessageBus();
+            builder
+                .RegisterInstance<IMessageBusProvider>(new StaticMessageBusProvider(providerBus))
+                .As<IMessageBusProvider>();
+            builder.RegisterMessageRegistrationBuilder();
+
+            IObjectResolver resolver = TrackDisposable(builder.Build());
+            IMessageRegistrationBuilder registrationBuilder =
+                resolver.Resolve<IMessageRegistrationBuilder>();
+            using MessageRegistrationLease lease = registrationBuilder.Build(
+                new MessageRegistrationBuildOptions()
+            );
+
+            Assert.AreSame(
+                providerBus,
+                lease.MessageBus,
+                "Registration extensions should prefer an explicitly registered IMessageBusProvider."
+            );
+        }
+
+        private sealed class VContainerConfiguredListener : MonoBehaviour, IDisposable
+        {
+            private IMessageBus _messageBus;
+            private MessageRegistrationToken _token;
+
+            internal int ReceivedCount { get; private set; }
+
+            internal void Initialize(IMessageBus messageBus)
+            {
+                _messageBus = messageBus;
+                MessagingComponent messagingComponent = GetComponent<MessagingComponent>();
+                messagingComponent.Configure(_messageBus, MessageBusRebindMode.RebindActive);
+
+                _token = messagingComponent.Create(this);
+                _ = _token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++ReceivedCount);
+                _token.Enable();
+            }
+
+            public void Dispose()
+            {
+                _token?.Disable();
+                _token = null;
+                _messageBus = null;
+            }
+        }
+
+        private sealed class StaticMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus;
+
+            public StaticMessageBusProvider(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+    }
+#endif
+}

package/Tests/Runtime/Integrations/VContainer/VContainerIntegrationTests.cs.meta

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

package/Tests/Runtime/Integrations/VContainer/WallstopStudios.DxMessaging.Tests.Runtime.VContainer.asmdef

@@ -0,0 +1,37 @@
+{
+  "name": "WallstopStudios.DxMessaging.Tests.Runtime.VContainer",
+  "rootNamespace": "DxMessaging.Tests.Runtime.VContainer",
+  "references": [
+    "UnityEngine.TestRunner",
+    "UnityEditor.TestRunner",
+    "WallstopStudios.DxMessaging",
+    "WallstopStudios.DxMessaging.Tests.Runtime",
+    "VContainer",
+    "WallstopStudios.DxMessaging.VContainer"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": true,
+  "precompiledReferences": ["nunit.framework.dll"],
+  "autoReferenced": true,
+  "defineConstraints": ["UNITY_INCLUDE_TESTS", "VCONTAINER_PRESENT"],
+  "versionDefines": [
+    {
+      "name": "jp.cysharp.vcontainer",
+      "expression": "0.0.1",
+      "define": "VCONTAINER_PRESENT"
+    },
+    {
+      "name": "jp.hadashikick.vcontainer",
+      "expression": "0.0.1",
+      "define": "VCONTAINER_PRESENT"
+    },
+    {
+      "name": "VContainer",
+      "expression": "0.0.1",
+      "define": "VCONTAINER_PRESENT"
+    }
+  ],
+  "noEngineReferences": false
+}

package/Tests/Runtime/Integrations/VContainer/WallstopStudios.DxMessaging.Tests.Runtime.VContainer.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5f7445560b0b4cbd9209d399362c2cb1
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/VContainer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6ec0c3c7cce7411da18c57b6e1f998c7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/Zenject/WallstopStudios.DxMessaging.Tests.Runtime.Zenject.asmdef

@@ -0,0 +1,37 @@
+{
+  "name": "WallstopStudios.DxMessaging.Tests.Runtime.Zenject",
+  "rootNamespace": "DxMessaging.Tests.Runtime.Zenject",
+  "references": [
+    "UnityEngine.TestRunner",
+    "UnityEditor.TestRunner",
+    "WallstopStudios.DxMessaging",
+    "WallstopStudios.DxMessaging.Tests.Runtime",
+    "Zenject",
+    "WallstopStudios.DxMessaging.Zenject"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": true,
+  "precompiledReferences": ["nunit.framework.dll"],
+  "autoReferenced": true,
+  "defineConstraints": ["UNITY_INCLUDE_TESTS", "ZENJECT_PRESENT"],
+  "versionDefines": [
+    {
+      "name": "com.extenject.zenject",
+      "expression": "0.0.1",
+      "define": "ZENJECT_PRESENT"
+    },
+    {
+      "name": "com.modesttree.zenject",
+      "expression": "0.0.1",
+      "define": "ZENJECT_PRESENT"
+    },
+    {
+      "name": "com.svermeulen.extenject",
+      "expression": "0.0.1",
+      "define": "ZENJECT_PRESENT"
+    }
+  ],
+  "noEngineReferences": false
+}

package/Tests/Runtime/Integrations/Zenject/WallstopStudios.DxMessaging.Tests.Runtime.Zenject.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9f1b23c34d3045cc9b15e0985e52c2bf
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations/Zenject/ZenjectIntegrationTests.cs

@@ -0,0 +1,140 @@
+namespace DxMessaging.Tests.Runtime.Zenject
+{
+#if ZENJECT_PRESENT
+    using DxMessaging.Core;
+    using System.Reflection;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using DxMessaging.Unity;
+    using DxMessaging.Unity.Integrations.Zenject;
+    using global::Zenject;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class ZenjectIntegrationTests : UnityFixtureBase
+    {
+        [Test]
+        public void InstallerBindsMessageBusAndConfiguratorAppliesIt()
+        {
+            DiContainer container = new();
+            container.BindInterfacesAndSelfTo<MessageBus>().AsSingle();
+
+            IMessageBus resolvedBus = container.Resolve<IMessageBus>();
+            Assert.IsNotNull(resolvedBus, "Zenject installer should bind IMessageBus.");
+
+            GameObject go = Track(
+                new GameObject(
+                    nameof(InstallerBindsMessageBusAndConfiguratorAppliesIt),
+                    typeof(MessagingComponent),
+                    typeof(ZenjectConfiguredListener)
+                )
+            );
+
+            ZenjectConfiguredListener listener = go.GetComponent<ZenjectConfiguredListener>();
+            listener.Initialize(resolvedBus);
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(resolvedBus);
+
+            Assert.AreEqual(
+                1,
+                listener.ReceivedCount,
+                "Listener should observe messages emitted through the container-provided bus."
+            );
+        }
+
+        [Test]
+        public void RegistrationInstallerProvidesBuilderBoundToContainerBus()
+        {
+            DiContainer container = new();
+            container.BindInterfacesAndSelfTo<MessageBus>().AsSingle();
+
+            DxMessagingRegistrationInstaller installer = new DxMessagingRegistrationInstaller();
+            installer.RunInstallBindings(container);
+
+            IMessageRegistrationBuilder registrationBuilder =
+                container.Resolve<IMessageRegistrationBuilder>();
+            Assert.NotNull(registrationBuilder);
+
+            using MessageRegistrationLease lease = registrationBuilder.Build(
+                new MessageRegistrationBuildOptions()
+            );
+            Assert.AreSame(
+                container.Resolve<IMessageBus>(),
+                lease.MessageBus,
+                "Builder resolved by the installer should default to the container-provided bus."
+            );
+        }
+
+        [Test]
+        public void RegistrationInstallerPrefersBoundProvider()
+        {
+            DiContainer container = new();
+            MessageBus providerBus = new();
+            container
+                .Bind<IMessageBusProvider>()
+                .FromInstance(new FixedMessageBusProvider(providerBus))
+                .AsSingle();
+            container.BindInterfacesAndSelfTo<MessageBus>().AsSingle();
+
+            DxMessagingRegistrationInstaller installer = new DxMessagingRegistrationInstaller();
+            installer.RunInstallBindings(container);
+
+            IMessageRegistrationBuilder registrationBuilder =
+                container.Resolve<IMessageRegistrationBuilder>();
+            using MessageRegistrationLease lease = registrationBuilder.Build(
+                new MessageRegistrationBuildOptions()
+            );
+
+            Assert.AreSame(
+                providerBus,
+                lease.MessageBus,
+                "Builder should prefer the container-provided IMessageBusProvider when available."
+            );
+        }
+
+        private sealed class ZenjectConfiguredListener : MonoBehaviour
+        {
+            private IMessageBus _messageBus;
+            private MessageRegistrationToken _token;
+
+            internal int ReceivedCount { get; private set; }
+
+            internal void Initialize(IMessageBus messageBus)
+            {
+                _messageBus = messageBus;
+                MessagingComponent messagingComponent = GetComponent<MessagingComponent>();
+                messagingComponent.Configure(_messageBus, MessageBusRebindMode.RebindActive);
+
+                _token = messagingComponent.Create(this);
+                _ = _token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++ReceivedCount);
+                _token.Enable();
+            }
+
+            private void OnDestroy()
+            {
+                _token?.Disable();
+                _token = null;
+                _messageBus = null;
+            }
+        }
+
+        private sealed class FixedMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus;
+
+            public FixedMessageBusProvider(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+    }
+#endif
+}

package/Tests/Runtime/Integrations/Zenject/ZenjectIntegrationTests.cs.meta

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

package/Tests/Runtime/Integrations/Zenject.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3b182b8e1e904128a628c9a4c53d3db1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Integrations.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 68dfb5c77c6e4d35a3ffca90d6be9f6d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: