com.kylin.di 1.0.0

package/Runtime/Attributes/InjectAttribute.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3e5f7e6b086bb9e4f9c911136e39f546

package/Runtime/Attributes/ViewModelAttribute.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Kylin.DI
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class ViewModelAttribute : Attribute
+    {
+        public bool IsGlobal { get; }
+        public string[] SceneNames { get; }
+
+        public ViewModelAttribute(bool isGlobal = false, params string[] sceneNames)
+        {
+            IsGlobal = isGlobal;
+            SceneNames = sceneNames ?? Array.Empty<string>();
+        }
+    }
+}

package/Runtime/Attributes/ViewModelAttribute.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d5d76843a2ec370499bd54d883ab5e6b

package/Runtime/Attributes.meta

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

package/Runtime/Core/DIBehaviour.cs

@@ -0,0 +1,70 @@
+using Kylin.SubscribableProperty;
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    /// <summary>
+    /// DI 지원 MonoBehaviour 기본 클래스.
+    /// LifetimeScope.Initialize() 시 Push 방식으로 주입됨.
+    /// 동적 생성 시 scope.Instantiate() 또는 scope.InjectGameObject() 사용.
+    /// OnDisable 시 구독 정리.
+    ///
+    /// 사용 예시:
+    /// <code>
+    /// public class PlayerController : DIBehaviour
+    /// {
+    ///     [Inject] private IPlayerService _playerService;
+    ///     [Inject] private IInputService _inputService;
+    ///
+    ///     void Start()
+    ///     {
+    ///         _playerService.Health.Subscribe(OnHealthChanged).AddTo(_cd);
+    ///     }
+    /// }
+    /// </code>
+    /// </summary>
+    public abstract class DIBehaviour : MonoBehaviour, IInjectable
+    {
+        /// <summary>
+        /// 구독 정리용 CompositeDisposable.
+        /// Subscribe().AddTo(_cd) 패턴으로 사용.
+        /// </summary>
+        protected CompositeDisposable _cd = new();
+
+        /// <summary>
+        /// 캐싱된 스코프.
+        /// </summary>
+        private IScope _cachedScope;
+
+        /// <summary>
+        /// 현재 사용 중인 스코프.
+        /// </summary>
+        protected IScope Scope => _cachedScope;
+
+        protected virtual void OnEnable() { }
+
+        protected virtual void OnDisable()
+        {
+            Dispose();
+        }
+
+        /// <summary>
+        /// 구독 정리 및 리소스 해제.
+        /// OnDisable에서 자동 호출됨.
+        /// </summary>
+        public virtual void Dispose()
+        {
+            _cd?.Dispose();
+            _cd = new CompositeDisposable();
+        }
+
+        /// <summary>
+        /// LifetimeScope.InjectChildren() 또는 scope.InjectGameObject()에서 호출.
+        /// Push 주입 시 스코프 참조를 캐싱.
+        /// </summary>
+        internal void SetInjected(IScope scope)
+        {
+            _cachedScope = scope;
+        }
+    }
+}

package/Runtime/Core/DIBehaviour.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cd9f6a435250dea4a92e2853488740d0

package/Runtime/Core/LifetimeScope.cs

@@ -0,0 +1,264 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    /// <summary>
+    /// 스코프 기반 의존성 관리를 위한 추상 MonoBehaviour.
+    /// Initialize() 시 하위 계층의 IInjectable MonoBehaviour에 일괄 주입 (Push).
+    /// child LifetimeScope 경계에서 탐색 중단 (하위 스코프의 주입 영역 침범 방지).
+    ///
+    /// 사용 방법:
+    /// 1. 이 클래스를 상속받은 클래스 생성
+    /// 2. Configure(ScopeBuilder builder)에서 builder.Bind 등으로 서비스 등록
+    /// 3. 씬에 해당 컴포넌트를 하나 배치
+    ///
+    /// 예시:
+    /// <code>
+    /// public class BattleSceneScope : LifetimeScope
+    /// {
+    ///     protected override void Configure(ScopeBuilder builder)
+    ///     {
+    ///         builder.Bind&lt;IBattleService&gt;().To&lt;BattleService&gt;().AsScoped();
+    ///     }
+    /// }
+    /// </code>
+    /// </summary>
+    public abstract class LifetimeScope : MonoBehaviour
+    {
+        // === Static Registry ===
+        private static readonly List<LifetimeScope> _activeScopes = new();
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void ResetStatic()
+        {
+            _activeScopes.Clear();
+        }
+
+        // === Inspector Fields ===
+
+        [Header("Scope Hierarchy")]
+        [SerializeField]
+        [Tooltip("부모 LifetimeScope. 없으면 RootScope로 생성됨.")]
+        private LifetimeScope _parent;
+
+        [SerializeField]
+        [Tooltip("true면 Awake에서 자동 초기화, false면 수동으로 Initialize() 호출 필요")]
+        private bool _autoInitialize = true;
+
+        // === Instance State ===
+
+        private IScope _scope;
+        private bool _isInitialized;
+        private int _hierarchyDepth;
+
+        /// <summary>
+        /// 이 LifetimeScope의 IScope.
+        /// </summary>
+        public IScope Scope => _scope;
+
+        /// <summary>
+        /// 초기화 완료 여부
+        /// </summary>
+        public bool IsInitialized => _isInitialized;
+
+        #region Unity Lifecycle
+
+        protected virtual void Awake()
+        {
+            if (_autoInitialize)
+            {
+                Initialize();
+            }
+        }
+
+        protected virtual void OnDestroy()
+        {
+            Dispose();
+        }
+
+        #endregion
+
+        #region Public API
+
+        /// <summary>
+        /// 수동 초기화.
+        /// _autoInitialize가 false일 때 사용.
+        /// </summary>
+        public void Initialize()
+        {
+            if (_isInitialized)
+            {
+                Debug.LogWarning($"[LifetimeScope] {GetType().Name} is already initialized.");
+                return;
+            }
+
+            var builder = new ScopeBuilder();
+            Configure(builder);
+
+            if (_parent != null)
+            {
+                if (!_parent.IsInitialized)
+                {
+                    _parent.Initialize();
+                }
+                _scope = builder.Build(_parent.Scope);
+            }
+            else
+            {
+                // parent가 없으면 RootScope로 빌드
+                _scope = builder.Build(parent: null);
+                KDI.SetRootScope(_scope);
+            }
+
+            // static registry 등록
+            _hierarchyDepth = ComputeDepth(transform);
+            _activeScopes.Add(this);
+
+            _isInitialized = true;
+
+            // 하위 계층 IInjectable 일괄 주입 (Push)
+            InjectChildren();
+
+            Debug.Log($"[LifetimeScope] {GetType().Name} initialized.");
+        }
+
+        /// <summary>
+        /// 스코프 정리.
+        /// OnDestroy에서 자동 호출됨.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!_isInitialized)
+                return;
+
+            _activeScopes.Remove(this);
+            _scope?.Dispose();
+            _scope = null;
+            _isInitialized = false;
+
+            Debug.Log($"[LifetimeScope] {GetType().Name} disposed.");
+        }
+
+        #endregion
+
+        #region Push Injection
+
+        /// <summary>
+        /// 하위 계층의 IInjectable MonoBehaviour를 찾아 일괄 주입.
+        /// child LifetimeScope 경계에서 탐색을 중단하여 하위 스코프 영역을 침범하지 않는다.
+        /// </summary>
+        private void InjectChildren()
+        {
+            InjectHierarchy(transform);
+        }
+
+        private void InjectHierarchy(Transform current)
+        {
+            for (int i = 0; i < current.childCount; i++)
+            {
+                var child = current.GetChild(i);
+
+                // child LifetimeScope가 있으면 탐색 중단 (그 scope의 영역)
+                if (child.TryGetComponent<LifetimeScope>(out _))
+                    continue;
+
+                // 이 GameObject의 IInjectable 컴포넌트 주입
+                var injectables = child.GetComponents<IInjectable>();
+                foreach (var injectable in injectables)
+                {
+                    DependencyInjector.Inject(injectable, _scope);
+
+                    if (injectable is DIBehaviour dib)
+                        dib.SetInjected(_scope);
+                }
+
+                // [Inject] 필드가 있지만 IInjectable 미구현인 MonoBehaviour 경고
+                var behaviours = child.GetComponents<MonoBehaviour>();
+                foreach (var mb in behaviours)
+                {
+                    if (mb == null || mb is IInjectable) continue;
+                    DependencyInjector.WarnIfHasInjectFieldsWithoutIInjectable(mb);
+                }
+
+                // 재귀
+                InjectHierarchy(child);
+            }
+        }
+
+        #endregion
+
+        #region Static Helpers (Registry 기반)
+
+        /// <summary>
+        /// static registry에서 가장 가까운 LifetimeScope 찾기.
+        /// GetComponentInParent 대신 Transform.IsChildOf (네이티브 호출) 사용.
+        /// </summary>
+        public static LifetimeScope Find(Transform from) => FindInternal(from);
+
+        public static LifetimeScope Find(GameObject from) => FindInternal(from?.transform);
+
+        public static LifetimeScope Find(Component from) => FindInternal(from?.transform);
+
+        private static LifetimeScope FindInternal(Transform from)
+        {
+            if (from == null) return null;
+
+            LifetimeScope best = null;
+            int bestDepth = -1;
+
+            for (int i = 0; i < _activeScopes.Count; i++)
+            {
+                var scope = _activeScopes[i];
+                if (scope == null || !scope._isInitialized) continue;
+
+                if (from.IsChildOf(scope.transform))
+                {
+                    if (scope._hierarchyDepth > bestDepth)
+                    {
+                        bestDepth = scope._hierarchyDepth;
+                        best = scope;
+                    }
+                }
+            }
+
+            return best;
+        }
+
+        /// <summary>
+        /// 씬에서 루트 LifetimeScope 찾기.
+        /// </summary>
+        public static LifetimeScope FindRoot()
+        {
+            for (int i = 0; i < _activeScopes.Count; i++)
+            {
+                if (_activeScopes[i]._parent == null)
+                    return _activeScopes[i];
+            }
+            return null;
+        }
+
+        private static int ComputeDepth(Transform t)
+        {
+            int depth = 0;
+            while (t.parent != null)
+            {
+                depth++;
+                t = t.parent;
+            }
+            return depth;
+        }
+
+        #endregion
+
+        #region Abstract
+
+        /// <summary>
+        /// 서비스 등록.
+        /// 하위 클래스에서 구현하여 builder.Bind 등으로 서비스 등록.
+        /// </summary>
+        protected abstract void Configure(ScopeBuilder builder);
+
+        #endregion
+    }
+}

package/Runtime/Core/LifetimeScope.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f4993c3e3e695584782dec19defb682a

package/Runtime/Core.meta

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

package/Runtime/DI/DependencyBuilder.cs

@@ -0,0 +1,114 @@
+using System;
+
+namespace Kylin.DI
+{
+    public class DependencyBuilder<T> where T : class
+    {
+        private readonly ScopeBuilder _builder;
+        private readonly Type _serviceType;
+        private Type _implementationType;
+        private Lifetime _lifetime = Lifetime.Singleton;
+        private object _instance;
+        private Func<IScope, object> _factory;
+
+        internal DependencyBuilder(ScopeBuilder builder, Type serviceType)
+        {
+            _builder = builder;
+            _serviceType = serviceType;
+        }
+
+        /// <summary>
+        /// 구현타입 지정
+        /// </summary>
+        public DependencyBuilder<T> To<TImplementation>()
+            where TImplementation : IDependencyObject, T
+        {
+            _implementationType = typeof(TImplementation);
+            return this;
+        }
+
+        /// <summary>
+        /// 싱글톤 (RootScope에서만 허용)
+        /// </summary>
+        public void AsSingleton()
+        {
+            _lifetime = Lifetime.Singleton;
+            FinishRegistration();
+        }
+
+        /// <summary>
+        /// 매번 새 인스턴스
+        /// </summary>
+        public void AsTransient()
+        {
+            _lifetime = Lifetime.Transient;
+            FinishRegistration();
+        }
+
+        /// <summary>
+        /// 스코프 내 단일 인스턴스
+        /// </summary>
+        public void AsScoped()
+        {
+            _lifetime = Lifetime.Scoped;
+            FinishRegistration();
+        }
+
+        public void FromInstance(T instance)
+        {
+            if (instance is IDependencyObject)
+            {
+                _instance = instance;
+                FinishRegistration();
+            }
+            else
+            {
+                throw new ArgumentException($"Instance must implement IDependencyObject");
+            }
+        }
+
+        /// <summary>
+        /// 팩토리 등록
+        /// </summary>
+        public DependencyBuilder<T> FromFactory(Func<IScope, T> factory)
+        {
+            _factory = scope => factory(scope);
+            return this;
+        }
+
+        private void FinishRegistration()
+        {
+            if (_instance != null)
+            {
+                _builder.AddRegistration(new Registration
+                {
+                    ServiceType = _serviceType,
+                    Instance = _instance,
+                    Lifetime = Lifetime.Scoped
+                });
+            }
+            else if (_factory != null)
+            {
+                _builder.AddRegistration(new Registration
+                {
+                    ServiceType = _serviceType,
+                    Factory = _factory,
+                    Lifetime = _lifetime
+                });
+            }
+            else if (_implementationType != null)
+            {
+                _builder.AddRegistration(new Registration
+                {
+                    ServiceType = _serviceType,
+                    ImplementationType = _implementationType,
+                    Lifetime = _lifetime
+                });
+            }
+            else
+            {
+                throw new InvalidOperationException("[KDI] Registration is incomplete");
+            }
+        }
+    }
+}

package/Runtime/DI/DependencyBuilder.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5809585d6abc44d4994f34b9dfe288d9

package/Runtime/DI/DependencyInjector.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    public static class DependencyInjector
+    {
+        private static readonly ConcurrentDictionary<Type, FieldInfo[]> _fieldCache
+            = new ConcurrentDictionary<Type, FieldInfo[]>();
+
+        public static FieldInfo[] GetCachedInjectableFields(Type type)
+        {
+            return _fieldCache.GetOrAdd(type, t =>
+            {
+                var fieldList = new List<FieldInfo>();
+                var currentType = t;
+                while (currentType != null && currentType != typeof(MonoBehaviour) && currentType != typeof(object))
+                {
+                    var fields = currentType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
+                        .Where(f => f.GetCustomAttribute<InjectAttribute>() != null);
+                    fieldList.AddRange(fields);
+                    currentType = currentType.BaseType;
+                }
+                return fieldList.ToArray();
+            });
+        }
+
+        /// <summary>
+        /// scope 없이 호출 시 KDI.RootScope에서 Resolve
+        /// </summary>
+        public static void Inject(this IInjectable target)
+        {
+            Inject(target, KDI.RootScope);
+        }
+
+        public static void Inject(this IInjectable target, IScope scope)
+        {
+            if (target == null || scope == null) return;
+
+            var fields = GetCachedInjectableFields(target.GetType());
+            if (fields.Length == 0)
+            {
+                if (target is IPostInjectable post)
+                    post.PostInject();
+                return;
+            }
+
+            // Phase 1: 모든 의존성 Resolve 시도 — 하나라도 실패하면 전체 주입 중단
+            var resolved = new object[fields.Length];
+            for (int i = 0; i < fields.Length; i++)
+            {
+                try
+                {
+                    resolved[i] = scope.Resolve(fields[i].FieldType);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError(
+                        $"[KDI] {target.GetType().Name}.{fields[i].Name} ({fields[i].FieldType.Name}) resolve 실패: {ex.Message}\n" +
+                        $"  → 주입 중단: {target.GetType().Name}의 모든 [Inject] 필드가 주입되지 않았습니다.");
+                    return;
+                }
+            }
+
+            // Phase 2: 전부 성공 — 일괄 주입
+            for (int i = 0; i < fields.Length; i++)
+            {
+                fields[i].SetValue(target, resolved[i]);
+            }
+
+            if (target is IPostInjectable postInjectable)
+            {
+                postInjectable.PostInject();
+            }
+        }
+
+        /// <summary>
+        /// [Inject] 필드가 있지만 IInjectable을 구현하지 않은 타입 경고.
+        /// Scope.CreateInstance 및 LifetimeScope.InjectHierarchy에서 호출.
+        /// </summary>
+        public static void WarnIfHasInjectFieldsWithoutIInjectable(object target)
+        {
+            if (target == null || target is IInjectable) return;
+
+            var fields = GetCachedInjectableFields(target.GetType());
+            if (fields.Length > 0)
+            {
+                var fieldNames = string.Join(", ", fields.Select(f => f.Name));
+                Debug.LogWarning(
+                    $"[KDI] {target.GetType().Name}에 [Inject] 필드({fieldNames})가 있지만 " +
+                    $"IInjectable을 구현하지 않았습니다. 주입이 수행되지 않습니다.");
+            }
+        }
+
+        public static void ClearCache()
+        {
+            _fieldCache.Clear();
+        }
+    }
+}

package/Runtime/DI/DependencyInjector.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 28225fb11a729c44b8709cad344b2080

package/Runtime/DI/InstanceFactory.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Reflection;
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    internal static class InstanceFactory
+    {
+        private static readonly ConcurrentDictionary<Type, Func<object>> _cache = new();
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void Reset() => _cache.Clear();
+
+        public static object Create(Type type)
+        {
+            return _cache.GetOrAdd(type, BuildFactory)();
+        }
+
+        private static Func<object> BuildFactory(Type type)
+        {
+            var ctor = type.GetConstructor(
+                BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null);
+
+            if (ctor == null)
+                throw new InvalidOperationException(
+                    $"[KDI] {type.Name}에 public 파라미터 없는 생성자가 없습니다.");
+
+            var newExpr = Expression.New(ctor);
+            var lambda = Expression.Lambda<Func<object>>(
+                Expression.Convert(newExpr, typeof(object)));
+            return lambda.Compile();
+        }
+    }
+}

package/Runtime/DI/InstanceFactory.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: dd04a076fe661f547810aba13c355ff9