Timeless refactor

src/Core/FileTime.Core.Services/ContentProviderBase.cs

@@ -4,6 +4,7 @@ using System.Reactive.Subjects;
 using DynamicData;
 using FileTime.Core.Enums;
 using FileTime.Core.Models;
+using FileTime.Core.Timeline;
 
 namespace FileTime.Core.Services;
 
@@ -11,10 +12,10 @@ public abstract class ContentProviderBase : IContentProvider
 {
     private readonly ReadOnlyExtensionCollection _extensions;
 
-    protected BehaviorSubject<IObservable<IChangeSet<IAbsolutePath>>?> Items { get; } = new(null);
+    protected BehaviorSubject<IObservable<IChangeSet<AbsolutePath>>?> Items { get; } = new(null);
     protected ExtensionCollection Extensions { get; }
 
-    IObservable<IObservable<IChangeSet<IAbsolutePath>>?> IContainer.Items => Items;
+    IObservable<IObservable<IChangeSet<AbsolutePath>>?> IContainer.Items => Items;
 
     public string Name { get; }
 
@@ -34,7 +35,7 @@ public abstract class ContentProviderBase : IContentProvider
 
     public IContentProvider Provider => this;
 
-    public IAbsolutePath? Parent => null;
+    public AbsolutePath? Parent => null;
 
     public DateTime? CreatedAt => null;
 
@@ -45,6 +46,7 @@ public abstract class ContentProviderBase : IContentProvider
     IObservable<bool> IContainer.IsLoading => IsLoading.AsObservable();
 
     public AbsolutePathType Type => AbsolutePathType.Container;
+    public PointInTime PointInTime { get; } = PointInTime.Eternal;
 
     public IObservable<IEnumerable<Exception>> Exceptions => Observable.Return(Enumerable.Empty<Exception>());
 
@@ -60,21 +62,21 @@ public abstract class ContentProviderBase : IContentProvider
 
     public virtual Task OnEnter() => Task.CompletedTask;
 
-    public virtual async Task<IItem> GetItemByFullNameAsync(
-        FullName fullName,
+    public virtual async Task<IItem> GetItemByFullNameAsync(FullName fullName,
+        PointInTime pointInTime,
         bool forceResolve = false,
         AbsolutePathType forceResolvePathType = AbsolutePathType.Unknown,
         ItemInitializationSettings itemInitializationSettings = default)
-        => await GetItemByNativePathAsync(GetNativePath(fullName), forceResolve, forceResolvePathType,
+        => await GetItemByNativePathAsync(GetNativePath(fullName), pointInTime, forceResolve, forceResolvePathType,
             itemInitializationSettings);
 
-    public abstract Task<IItem> GetItemByNativePathAsync(
-        NativePath nativePath,
+    public abstract Task<IItem> GetItemByNativePathAsync(NativePath nativePath,
+        PointInTime pointInTime,
         bool forceResolve = false,
         AbsolutePathType forceResolvePathType = AbsolutePathType.Unknown,
         ItemInitializationSettings itemInitializationSettings = default);
 
-    public abstract Task<List<IAbsolutePath>> GetItemsByContainerAsync(FullName fullName);
+    public abstract Task<List<AbsolutePath>> GetItemsByContainerAsync(FullName fullName, PointInTime pointInTime);
     public abstract NativePath GetNativePath(FullName fullName);
 
     public abstract Task<byte[]?> GetContentAsync(IElement element,

src/Core/FileTime.Core.Services/Tab.cs

@@ -3,22 +3,30 @@ using System.Reactive.Subjects;
 using DynamicData;
 using DynamicData.Alias;
 using FileTime.Core.Models;
+using FileTime.Core.Timeline;
 
 namespace FileTime.Core.Services;
 
 public class Tab : ITab
 {
+    private readonly ITimelessContentProvider _timelessContentProvider;
     private readonly BehaviorSubject<IContainer?> _currentLocation = new(null);
-    private readonly BehaviorSubject<IAbsolutePath?> _currentSelectedItem = new(null);
+    private readonly BehaviorSubject<AbsolutePath?> _currentSelectedItem = new(null);
     private readonly SourceList<ItemFilter> _itemFilters = new();
-    private IAbsolutePath? _currentSelectedItemCached;
+    private AbsolutePath? _currentSelectedItemCached;
+    private PointInTime _currentPointInTime;
 
     public IObservable<IContainer?> CurrentLocation { get; }
     public IObservable<IObservable<IChangeSet<IItem>>?> CurrentItems { get; }
-    public IObservable<IAbsolutePath?> CurrentSelectedItem { get; }
+    public IObservable<AbsolutePath?> CurrentSelectedItem { get; }
 
-    public Tab()
+    public Tab(ITimelessContentProvider timelessContentProvider)
     {
+        _timelessContentProvider = timelessContentProvider;
+        _currentPointInTime = null!;
+        
+        _timelessContentProvider.CurrentPointInTime.Subscribe(p => _currentPointInTime = p);
+        
         CurrentLocation = _currentLocation.DistinctUntilChanged().Publish(null).RefCount();
         CurrentItems =
             Observable.Merge(
@@ -32,9 +40,9 @@ public class Tab : ITab
                         (items, filters) => items?.Where(i => filters.All(f => f.Filter(i)))),
                     CurrentLocation
                         .Where(c => c is null)
-                        .Select(_ => (IObservable<IChangeSet<IItem>>?) null)
+                        .Select(_ => (IObservable<IChangeSet<IItem>>?)null)
                 )
-                .Publish((IObservable<IChangeSet<IItem>>?) null)
+                .Publish((IObservable<IChangeSet<IItem>>?)null)
                 .RefCount();
 
         CurrentSelectedItem =
@@ -66,22 +74,22 @@ public class Tab : ITab
         });
     }
 
-    private async Task<IItem> MapItem(IAbsolutePath item) => await item.ResolveAsync(true);
+    private async Task<IItem> MapItem(AbsolutePath item) => await item.ResolveAsync(true);
 
     public void Init(IContainer currentLocation)
     {
         _currentLocation.OnNext(currentLocation);
     }
 
-    private static IAbsolutePath? GetSelectedItemByItems(IEnumerable<IItem> items)
+    private AbsolutePath? GetSelectedItemByItems(IEnumerable<IItem> items)
     {
         //TODO: 
-        return new AbsolutePath(items.First());
+        return new AbsolutePath(_timelessContentProvider, items.First());
     }
 
     public void SetCurrentLocation(IContainer newLocation) => _currentLocation.OnNext(newLocation);
 
-    public void SetSelectedItem(IAbsolutePath newSelectedItem) => _currentSelectedItem.OnNext(newSelectedItem);
+    public void SetSelectedItem(AbsolutePath newSelectedItem) => _currentSelectedItem.OnNext(newSelectedItem);
 
     public void AddItemFilter(ItemFilter filter) => _itemFilters.Add(filter);
     public void RemoveItemFilter(ItemFilter filter) => _itemFilters.Remove(filter);
@@ -95,7 +103,8 @@ public class Tab : ITab
     public async Task OpenSelected()
     {
         if (_currentSelectedItemCached == null) return;
-        var resolvedSelectedItem = await _currentSelectedItemCached.ContentProvider.GetItemByFullNameAsync(_currentSelectedItemCached.Path);
+        var resolvedSelectedItem =
+            await _currentSelectedItemCached.TimelessProvider.GetItemByFullNameAsync(_currentSelectedItemCached.Path, _currentPointInTime);
 
         if (resolvedSelectedItem is not IContainer resolvedContainer) return;
         SetCurrentLocation(resolvedContainer);