com.kylin.di 1.0.0

package/Runtime/SubscribableProperty/SubscribableDictionary.cs

@@ -0,0 +1,350 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Kylin.SubscribableProperty
+{
+    [Serializable]
+    public struct DictionaryChangeEvent<TKey, TValue>
+    {
+        public CollectionChangeType Type { get; }
+        public TKey Key { get; }
+        public TValue OldValue { get; }
+        public TValue NewValue { get; }
+
+        private DictionaryChangeEvent(CollectionChangeType type, TKey key, TValue oldValue, TValue newValue)
+        {
+            Type = type;
+            Key = key;
+            OldValue = oldValue;
+            NewValue = newValue;
+        }
+
+        public static DictionaryChangeEvent<TKey, TValue> Add(TKey key, TValue value)
+            => new DictionaryChangeEvent<TKey, TValue>(CollectionChangeType.Add, key, default, value);
+
+        public static DictionaryChangeEvent<TKey, TValue> Remove(TKey key, TValue value)
+            => new DictionaryChangeEvent<TKey, TValue>(CollectionChangeType.Remove, key, value, default);
+
+        public static DictionaryChangeEvent<TKey, TValue> Replace(TKey key, TValue oldValue, TValue newValue)
+            => new DictionaryChangeEvent<TKey, TValue>(CollectionChangeType.Replace, key, oldValue, newValue);
+
+        public static DictionaryChangeEvent<TKey, TValue> Clear()
+            => new DictionaryChangeEvent<TKey, TValue>(CollectionChangeType.Clear, default, default, default);
+    }
+    public interface IReadOnlySubscribableDictionary<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>
+    {
+        // 구독 메서드들
+        IDisposable Subscribe(Action<DictionaryChangeEvent<TKey, TValue>> onChanged, bool invokeForCurrentItems = false);
+        IDisposable SubscribeCount(Action<int> onCountChanged, bool invokeInitial = false);
+        IDisposable SubscribeAdd(Action<TKey, TValue> onAdd);
+        IDisposable SubscribeRemove(Action<TKey, TValue> onRemove);
+        IDisposable SubscribeReplace(Action<TKey, TValue, TValue> onReplace);
+    }
+    public interface ISubscribableDictionary<TKey, TValue> : IReadOnlySubscribableDictionary<TKey, TValue>, IDictionary<TKey, TValue>
+    {
+    }
+    [Serializable]
+    public class SubscribableDictionary<TKey, TValue> : ISubscribableDictionary<TKey, TValue>, ISerializationCallbackReceiver, ISubscribablePending
+    {
+        [SerializeField]
+        private List<TKey> _keys = new List<TKey>();
+
+        [SerializeField]
+        private List<TValue> _values = new List<TValue>();
+
+        private Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();
+
+        private event Action<DictionaryChangeEvent<TKey, TValue>> _dictionaryChanged;
+        private event Action<int> _countChanged;
+
+        [NonSerialized] private List<DictionaryChangeEvent<TKey, TValue>> _pendingChanges;
+        [NonSerialized] private bool _hasPendingCountChange;
+
+        public SubscribableDictionary()
+        {
+        }
+
+        public SubscribableDictionary(IDictionary<TKey, TValue> dictionary)
+        {
+            if (dictionary != null)
+            {
+                foreach (var kvp in dictionary)
+                {
+                    _dictionary[kvp.Key] = kvp.Value;
+                }
+                FullSyncToSerializedLists();
+            }
+        }
+
+        public SubscribableDictionary(int capacity)
+        {
+            _dictionary = new Dictionary<TKey, TValue>(capacity);
+        }
+
+        #region IDictionary<TKey, TValue> Implementation
+
+        public TValue this[TKey key]
+        {
+            get => _dictionary[key];
+            set
+            {
+                if (_dictionary.TryGetValue(key, out var oldValue))
+                {
+                    if (!EqualityComparer<TValue>.Default.Equals(oldValue, value))
+                    {
+                        _dictionary[key] = value;
+                        UpdateSerializedValue(key, value);
+                        NotifyDictionaryChanged(DictionaryChangeEvent<TKey, TValue>.Replace(key, oldValue, value));
+                    }
+                }
+                else
+                {
+                    Add(key, value);
+                }
+            }
+        }
+
+        public ICollection<TKey> Keys => _dictionary.Keys;
+        public ICollection<TValue> Values => _dictionary.Values;
+        public int Count => _dictionary.Count;
+        public bool IsReadOnly => false;
+
+        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;
+        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;
+
+        public void Add(TKey key, TValue value)
+        {
+            _dictionary.Add(key, value);
+            AddToSerializedLists(key, value);
+            NotifyDictionaryChanged(DictionaryChangeEvent<TKey, TValue>.Add(key, value));
+            NotifyCountChanged();
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item) => Add(item.Key, item.Value);
+
+        public bool Remove(TKey key)
+        {
+            if (_dictionary.TryGetValue(key, out var value))
+            {
+                _dictionary.Remove(key);
+                RemoveFromSerializedLists(key);
+                NotifyDictionaryChanged(DictionaryChangeEvent<TKey, TValue>.Remove(key, value));
+                NotifyCountChanged();
+                return true;
+            }
+            return false;
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            if (_dictionary.TryGetValue(item.Key, out var value) &&
+                EqualityComparer<TValue>.Default.Equals(value, item.Value))
+            {
+                return Remove(item.Key);
+            }
+            return false;
+        }
+
+        public void Clear()
+        {
+            if (_dictionary.Count > 0)
+            {
+                _dictionary.Clear();
+                ClearSerializedLists();
+                NotifyDictionaryChanged(DictionaryChangeEvent<TKey, TValue>.Clear());
+                NotifyCountChanged();
+            }
+        }
+
+        public bool ContainsKey(TKey key) => _dictionary.ContainsKey(key);
+        public bool Contains(KeyValuePair<TKey, TValue> item) => _dictionary.Contains(item);
+        public bool TryGetValue(TKey key, out TValue value) => _dictionary.TryGetValue(key, out value);
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            ((IDictionary<TKey, TValue>)_dictionary).CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        #endregion
+
+        #region Subscription Methods
+
+        public IDisposable Subscribe(Action<DictionaryChangeEvent<TKey, TValue>> onChanged, bool invokeForCurrentItems = false)
+        {
+            if (onChanged == null) throw new ArgumentNullException(nameof(onChanged));
+
+            if (invokeForCurrentItems)
+            {
+                foreach (var kvp in _dictionary)
+                {
+                    onChanged(DictionaryChangeEvent<TKey, TValue>.Add(kvp.Key, kvp.Value));
+                }
+            }
+
+            _dictionaryChanged += onChanged;
+            return new Disposable(() => _dictionaryChanged -= onChanged);
+        }
+
+        public IDisposable SubscribeCount(Action<int> onCountChanged, bool invokeInitial = false)
+        {
+            if (onCountChanged == null) throw new ArgumentNullException(nameof(onCountChanged));
+
+            if (invokeInitial)
+                onCountChanged(Count);
+
+            _countChanged += onCountChanged;
+            return new Disposable(() => _countChanged -= onCountChanged);
+        }
+
+        public IDisposable SubscribeAdd(Action<TKey, TValue> onAdd)
+        {
+            return Subscribe(change =>
+            {
+                if (change.Type == CollectionChangeType.Add)
+                    onAdd(change.Key, change.NewValue);
+            });
+        }
+
+        public IDisposable SubscribeRemove(Action<TKey, TValue> onRemove)
+        {
+            return Subscribe(change =>
+            {
+                if (change.Type == CollectionChangeType.Remove)
+                    onRemove(change.Key, change.OldValue);
+            });
+        }
+        public IDisposable SubscribeReplace(Action<TKey, TValue, TValue> onReplace)
+        {
+            return Subscribe(change =>
+            {
+                if (change.Type == CollectionChangeType.Replace)
+                    onReplace(change.Key, change.OldValue, change.NewValue);
+            });
+        }
+        #endregion
+
+        private void NotifyDictionaryChanged(DictionaryChangeEvent<TKey, TValue> changeEvent)
+        {
+            if (Reaction.IsActive)
+            {
+                _pendingChanges ??= new List<DictionaryChangeEvent<TKey, TValue>>();
+                _pendingChanges.Add(changeEvent);
+                Reaction.RegisterPending(this);
+            }
+            else
+            {
+                _dictionaryChanged?.Invoke(changeEvent);
+            }
+        }
+
+        private void NotifyCountChanged()
+        {
+            if (Reaction.IsActive)
+            {
+                _hasPendingCountChange = true;
+                Reaction.RegisterPending(this);
+            }
+            else
+            {
+                _countChanged?.Invoke(Count);
+            }
+        }
+
+        void ISubscribablePending.FlushPendingNotification()
+        {
+            if (_pendingChanges != null && _pendingChanges.Count > 0)
+            {
+                int count = _pendingChanges.Count;
+                for (int i = 0; i < count; i++)
+                {
+                    _dictionaryChanged?.Invoke(_pendingChanges[i]);
+                }
+                _pendingChanges.Clear();
+            }
+
+            if (_hasPendingCountChange)
+            {
+                _hasPendingCountChange = false;
+                _countChanged?.Invoke(Count);
+            }
+        }
+
+        #region Optimized Serialization Support
+
+        private void AddToSerializedLists(TKey key, TValue value)
+        {
+            _keys.Add(key);
+            _values.Add(value);
+        }
+
+        private void UpdateSerializedValue(TKey key, TValue newValue)
+        {
+            var index = _keys.IndexOf(key);
+            if (index >= 0)
+            {
+                _values[index] = newValue;
+            }
+            else
+            {
+                AddToSerializedLists(key, newValue);
+            }
+        }
+
+        private void RemoveFromSerializedLists(TKey key)
+        {
+            var index = _keys.IndexOf(key);
+            if (index >= 0)
+            {
+                _keys.RemoveAt(index);
+                _values.RemoveAt(index);
+            }
+        }
+
+        private void ClearSerializedLists()
+        {
+            _keys.Clear();
+            _values.Clear();
+        }
+
+        private void FullSyncToSerializedLists()
+        {
+            _keys.Clear();
+            _values.Clear();
+
+            foreach (var kvp in _dictionary)
+            {
+                _keys.Add(kvp.Key);
+                _values.Add(kvp.Value);
+            }
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            _dictionary.Clear();
+
+            for (int i = 0; i < _keys.Count && i < _values.Count; i++)
+            {
+                _dictionary[_keys[i]] = _values[i];
+            }
+        }
+
+        #endregion
+
+        private class Disposable : IDisposable
+        {
+            private readonly Action _onDispose;
+            public Disposable(Action onDispose) => _onDispose = onDispose;
+            public void Dispose() => _onDispose?.Invoke();
+        }
+    }
+}

package/Runtime/SubscribableProperty/SubscribableDictionary.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3cea4bebd8c84c8696eb0874aefbad0a
+timeCreated: 1755591584

package/Runtime/SubscribableProperty/SubscribableProperty.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Kylin.SubscribableProperty
+{
+    public interface IReadOnlySubscribableProperty<T>
+    {
+        T Value { get; }
+        IDisposable Subscribe(Action<T> onNext, bool invokeInitial = false);
+    }
+
+    public interface ISubscribableProperty<T> : IReadOnlySubscribableProperty<T>
+    {
+        new T Value { get; set; }
+    }
+    [Serializable]
+    public partial class SubscribableProperty<T> : ISubscribableProperty<T>, ISerializationCallbackReceiver, ISubscribablePending
+    {
+        [SerializeField]
+        private T value;
+
+        // Reaction 안에서 변경되는지 표시.
+        // 같은 스코프 내 다중 변경이 발생해도 outermost Dispose 시 최종 값으로 1회만 invoke
+        [NonSerialized]
+        private bool _hasPendingNotification;
+
+        public SubscribableProperty()
+        {
+            OnPropertyCreated();
+        }
+
+        public SubscribableProperty(T initValue)
+        {
+            value = initValue;
+            OnPropertyCreated();
+        }
+
+        public event Action<T> ValueChanged;
+
+        public T Value
+        {
+            get => value;
+            set
+            {
+                if (!EqualityComparer<T>.Default.Equals(this.value, value))
+                {
+                    this.value = value;
+                    if (Reaction.IsActive)
+                    {
+                        _hasPendingNotification = true;
+                        Reaction.RegisterPending(this);
+                    }
+                    else
+                    {
+                        ValueChanged?.Invoke(this.value);
+                    }
+                }
+            }
+        }
+
+        void ISubscribablePending.FlushPendingNotification()
+        {
+            if (!_hasPendingNotification) return;
+            _hasPendingNotification = false;
+            ValueChanged?.Invoke(value);
+        }
+
+        public IDisposable Subscribe(Action<T> onNext, bool invokeInitial = false)
+        {
+            if (onNext == null) throw new ArgumentNullException(nameof(onNext));
+
+            if (invokeInitial)
+                onNext(Value);
+
+            ValueChanged += onNext;
+            OnSubscribe(onNext);
+
+            return new Disposable(() =>
+            {
+                ValueChanged -= onNext;
+                OnUnsubscribe(onNext);
+            });
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize() { }
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+            => ValueChanged?.Invoke(value);
+
+        partial void OnPropertyCreated();
+        partial void OnSubscribe(Action<T> onNext);
+        partial void OnUnsubscribe(Action<T> onNext);
+
+        private class Disposable : IDisposable
+        {
+            private readonly Action _onDispose;
+            public Disposable(Action onDispose) => _onDispose = onDispose;
+            public void Dispose() => _onDispose();
+        }
+    }
+
+    public class ReadOnlySubscribableProperty<T> : IReadOnlySubscribableProperty<T>
+    {
+        private readonly ISubscribableProperty<T> _source;
+
+        public ReadOnlySubscribableProperty(ISubscribableProperty<T> source)
+        {
+            _source = source ?? throw new ArgumentNullException(nameof(source));
+        }
+
+        public T Value => _source.Value;
+
+        public IDisposable Subscribe(Action<T> onNext, bool invokeInitial = false)
+        {
+            return _source.Subscribe(onNext, invokeInitial);
+        }
+    }
+
+}

package/Runtime/SubscribableProperty/SubscribableProperty.cs.meta

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

package/Runtime/SubscribableProperty/SubscribablePropertyExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Kylin.SubscribableProperty
+{
+    public static class SubscribablePropertyExtensions
+    {
+        public static T AddTo<T>(this T disposable, CompositeDisposable cd) where T : IDisposable
+        {
+            if (disposable == null || cd == null)
+                return disposable;
+            cd.Add(disposable);
+            return disposable;
+        }
+    }
+
+    public class CompositeDisposable : IDisposable
+    {
+        private readonly List<IDisposable> _disposables = new();
+        public bool IsDisposed { get; private set; }
+        public void Add(IDisposable d) => _disposables.Add(d);
+        public void Dispose()
+        {
+            if (IsDisposed) return;
+            foreach (var d in _disposables) d.Dispose();
+            _disposables.Clear();
+            IsDisposed = true;
+        }
+
+        public void Clear()
+        {
+            if (IsDisposed) return;
+            foreach (var d in _disposables.ToArray()) d.Dispose();
+            _disposables.Clear();
+        }
+    }
+}

package/Runtime/SubscribableProperty/SubscribablePropertyExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d803b42e5424c46af66949d75ebb29f
+timeCreated: 1755326510

package/Runtime/SubscribableProperty/SubscribablePropertyLinq.cs

@@ -0,0 +1,86 @@
+using System;
+
+namespace Kylin.SubscribableProperty
+{
+    public static class SubscribablePropertyLinq
+    {
+        public static IReadOnlySubscribableProperty<TResult> Select<T, TResult>(this IReadOnlySubscribableProperty<T> source, Func<T, TResult> selector)
+        {
+            return new SelectSubscribableProperty<T, TResult>(source, selector);
+        }
+
+        public static IReadOnlySubscribableProperty<T> Where<T>(this IReadOnlySubscribableProperty<T> source, Func<T, bool> predicate)
+        {
+            return new WhereSubscribableProperty<T>(source, predicate);
+        }
+    }
+
+    internal class SelectSubscribableProperty<TSource, TResult> : IReadOnlySubscribableProperty<TResult>, IDisposable
+    {
+        private readonly IReadOnlySubscribableProperty<TSource> _source;
+        private readonly Func<TSource, TResult> _selector;
+        private readonly SubscribableProperty<TResult> _property;
+        private readonly IDisposable _subscription;
+
+        public TResult Value => _property.Value;
+
+        public SelectSubscribableProperty(IReadOnlySubscribableProperty<TSource> source, Func<TSource, TResult> selector)
+        {
+            _source = source;
+            _selector = selector;
+            _property = new SubscribableProperty<TResult>(_selector(_source.Value));
+            _subscription = _source.Subscribe(OnSourceValueChanged, invokeInitial: false);
+        }
+
+        private void OnSourceValueChanged(TSource value)
+        {
+            _property.Value = _selector(value);
+        }
+
+        public IDisposable Subscribe(Action<TResult> onNext, bool invokeInitial = false)
+        {
+            return _property.Subscribe(onNext, invokeInitial);
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+        }
+    }
+
+    internal class WhereSubscribableProperty<T> : IReadOnlySubscribableProperty<T>, IDisposable
+    {
+        private readonly IReadOnlySubscribableProperty<T> _source;
+        private readonly Func<T, bool> _predicate;
+        private readonly SubscribableProperty<T> _property;
+        private readonly IDisposable _subscription;
+
+        public T Value => _property.Value;
+
+        public WhereSubscribableProperty(IReadOnlySubscribableProperty<T> source, Func<T, bool> predicate)
+        {
+            _source = source;
+            _predicate = predicate;
+            _property = new SubscribableProperty<T>(source.Value);
+            _subscription = _source.Subscribe(OnSourceValueChanged, invokeInitial: true);
+        }
+
+        private void OnSourceValueChanged(T value)
+        {
+            if (_predicate(value))
+            {
+                _property.Value = value;
+            }
+        }
+
+        public IDisposable Subscribe(Action<T> onNext, bool invokeInitial = false)
+        {
+            return _property.Subscribe(onNext, invokeInitial);
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+        }
+    }
+}

package/Runtime/SubscribableProperty/SubscribablePropertyLinq.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 26289af3cb5e6de45a424314e45f6fe6

package/Runtime/SubscribableProperty.meta

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

package/Runtime/Update/IFixedUpdatable.cs

@@ -0,0 +1,16 @@
+namespace Kylin.DI
+{
+    /// <summary>
+    /// DI 기반 FixedUpdate 루프 인터페이스
+    /// - MonoBehaviour.FixedUpdate() 대신 사용
+    /// - UpdateLoopManager에서 고정 시간 간격으로 호출
+    /// </summary>
+    public interface IFixedUpdatable
+    {
+        /// <summary>
+        /// 고정 시간 간격으로 호출 (FixedUpdate와 동일한 타이밍)
+        /// </summary>
+        /// <param name="fixedDeltaTime">Time.fixedDeltaTime</param>
+        void KDIFixedUpdate(float fixedDeltaTime);
+    }
+}

package/Runtime/Update/IFixedUpdatable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 71d494350be8be747b69c543a7a73c64

package/Runtime/Update/ILateUpdatable.cs

@@ -0,0 +1,16 @@
+namespace Kylin.DI
+{
+    /// <summary>
+    /// DI 기반 LateUpdate 루프 인터페이스
+    /// - MonoBehaviour.LateUpdate() 대신 사용
+    /// - UpdateLoopManager에서 Update 이후 호출
+    /// </summary>
+    public interface ILateUpdatable
+    {
+        /// <summary>
+        /// Update 이후 호출 (LateUpdate와 동일한 타이밍)
+        /// </summary>
+        /// <param name="deltaTime">Time.deltaTime</param>
+        void KDILateUpdate(float deltaTime);
+    }
+}

package/Runtime/Update/ILateUpdatable.cs.meta

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

package/Runtime/Update/IUpdatable.cs

@@ -0,0 +1,16 @@
+namespace Kylin.DI
+{
+    /// <summary>
+    /// DI 기반 Update 루프 인터페이스
+    /// - MonoBehaviour.Update() 대신 사용
+    /// - UpdateLoopManager에서 매 프레임 호출
+    /// </summary>
+    public interface IUpdatable
+    {
+        /// <summary>
+        /// 매 프레임 호출 (Update와 동일한 타이밍)
+        /// </summary>
+        /// <param name="deltaTime">Time.deltaTime</param>
+        void KDIUpdate(float deltaTime);
+    }
+}

package/Runtime/Update/IUpdatable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4fae7fa43ac3e8345a88cfba8acf1380