From 499d3e8ba140dace8e79b1aec31a55affe2bff53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 29 Jul 2026 10:49:59 -0300 Subject: [PATCH] Rename the RxSharp namespace and assembly to ReactiveExtensionsSharp The published NuGet package has always been ReactiveExtensionsSharp (RxSharp itself was taken), but the assembly and every namespace stayed RxSharp - meaning what you install and what you `using` never matched. That's the exact kind of mismatch this project exists to eliminate elsewhere (see the recent Extras -> RxExtensions consolidation), so it shouldn't tolerate one at its own root. Renamed everything to line up: src/RxSharp -> src/ReactiveExtensionsSharp (and its .csproj), test/RxSharp.Tests -> test/ReactiveExtensionsSharp.Tests (and its .csproj), RxSharp.sln -> ReactiveExtensionsSharp.sln, every `namespace`/`using RxSharp*` becomes `ReactiveExtensionsSharp*`, plus matching updates to the publish workflow, docfx config, README, and CLAUDE.md. No AssemblyName/RootNamespace override needed - both already defaulted from the .csproj file name, so renaming the file was enough to produce ReactiveExtensionsSharp.dll directly. This breaks every existing `using RxSharp;` at every consumer, hence the 0.2.0 bump rather than another 0.1.x patch. All 840 tests pass, all three TFMs build clean, `dotnet format --verify-no-changes` is clean, and the assembly is still correctly strong-name signed. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01K92eapPm8e7mX7puT4cF4s --- .github/workflows/publish-nuget.yml | 4 +- CLAUDE.md | 24 ++++----- README.md | 16 +++--- RxSharp.sln => ReactiveExtensionsSharp.sln | 4 +- docfx_project/api/index.md | 6 +-- docfx_project/docfx.json | 6 +-- docfx_project/index.md | 2 +- handoff/blog-post-material.md | 8 +-- handoff/puppeteer-sharp-integration.md | 50 +++++++++---------- .../AsyncBridge.cs | 2 +- .../EmptyErrorException.cs | 2 +- .../Extras/AssumeNeverEmits.cs | 4 +- .../Extras/FilterAsync.cs | 4 +- .../Extras/FromCancellationToken.cs | 2 +- .../Extras/FromEventBuffered.cs | 6 +-- .../Extras/RaceWithSignalAndTimer.cs | 4 +- .../Extras/RetryAndRaceWithSignalAndTimer.cs | 4 +- .../Extras/Timeout.cs | 4 +- .../GroupedObservable.cs | 4 +- .../IGroupedObservable.cs | 2 +- .../IScheduler.cs | 2 +- .../NotFoundErrorException.cs | 2 +- .../Notification.cs | 10 ++-- .../Observable.Creation.cs | 8 +-- .../Observable.cs | 2 +- .../OperatorFunction.cs | 2 +- .../Operators/Audit.cs | 2 +- .../Operators/Buffer.cs | 2 +- .../Operators/BufferCount.cs | 2 +- .../Operators/BufferTime.cs | 2 +- .../Operators/BufferWhen.cs | 2 +- .../Operators/CatchError.cs | 2 +- .../Operators/CombineLatestAll.cs | 8 +-- .../Operators/CombineLatestWith.cs | 8 +-- .../Operators/ConcatAll.cs | 2 +- .../Operators/ConcatMap.cs | 2 +- .../Operators/ConcatMapTo.cs | 2 +- .../Operators/ConcatWith.cs | 6 +-- .../Operators/Count.cs | 2 +- .../Operators/Debounce.cs | 2 +- .../Operators/DebounceTime.cs | 2 +- .../Operators/DefaultIfEmpty.cs | 2 +- .../Operators/Delay.cs | 2 +- .../Operators/DelayWhen.cs | 2 +- .../Operators/Distinct.cs | 2 +- .../Operators/DistinctUntilChanged.cs | 2 +- .../Operators/ElementAt.cs | 2 +- .../Operators/EndWith.cs | 2 +- .../Operators/Every.cs | 2 +- .../Operators/ExhaustAll.cs | 2 +- .../Operators/ExhaustMap.cs | 2 +- .../Operators/Expand.cs | 2 +- .../Operators/Filter.cs | 2 +- .../Operators/Finalize.cs | 2 +- .../Operators/Find.cs | 2 +- .../Operators/FindIndex.cs | 2 +- .../Operators/First.cs | 2 +- .../Operators/GroupBy.cs | 4 +- .../Operators/IgnoreElements.cs | 2 +- .../Operators/IsEmpty.cs | 2 +- .../Operators/Last.cs | 2 +- .../Operators/Map.cs | 2 +- .../Operators/MapTo.cs | 2 +- .../Operators/Materialize.cs | 2 +- .../Operators/Max.cs | 2 +- .../Operators/MergeAll.cs | 2 +- .../Operators/MergeMap.cs | 2 +- .../Operators/MergeMapTo.cs | 2 +- .../Operators/MergeScan.cs | 2 +- .../Operators/MergeWith.cs | 6 +-- .../Operators/Min.cs | 2 +- .../Operators/OnErrorResumeNext.cs | 6 +-- .../Operators/Pairwise.cs | 2 +- .../Operators/Partition.cs | 2 +- .../Operators/Race.cs | 2 +- .../Operators/Reduce.cs | 2 +- .../Operators/Repeat.cs | 2 +- .../Operators/RepeatWhen.cs | 4 +- .../Operators/Retry.cs | 2 +- .../Operators/RetryWhen.cs | 4 +- .../Operators/Sample.cs | 2 +- .../Operators/Scan.cs | 2 +- .../Operators/SequenceEqual.cs | 2 +- .../Operators/Share.cs | 4 +- .../Operators/ShareConfig.cs | 6 +-- .../Operators/ShareReplay.cs | 4 +- .../Operators/Single.cs | 2 +- .../Operators/Skip.cs | 2 +- .../Operators/SkipLast.cs | 2 +- .../Operators/SkipUntil.cs | 2 +- .../Operators/SkipWhile.cs | 2 +- .../Operators/StartWith.cs | 2 +- .../Operators/SwitchAll.cs | 2 +- .../Operators/SwitchMap.cs | 2 +- .../Operators/SwitchMapTo.cs | 2 +- .../Operators/SwitchScan.cs | 2 +- .../Operators/Take.cs | 2 +- .../Operators/TakeLast.cs | 2 +- .../Operators/TakeUntil.cs | 2 +- .../Operators/TakeWhile.cs | 2 +- .../Operators/Tap.cs | 2 +- .../Operators/Throttle.cs | 2 +- .../Operators/ThrowIfEmpty.cs | 2 +- .../Operators/TimeInterval.cs | 4 +- .../Operators/Timestamp.cs | 4 +- .../Operators/ToArray.cs | 2 +- .../Operators/Window.cs | 4 +- .../Operators/WindowCount.cs | 4 +- .../Operators/WindowTime.cs | 4 +- .../Operators/WindowWhen.cs | 4 +- .../Operators/WithLatestFrom.cs | 2 +- .../Operators/ZipAll.cs | 8 +-- .../Operators/ZipWith.cs | 8 +-- .../RaceCore.cs | 2 +- .../ReactiveExtensionsSharp.csproj} | 8 +-- .../RxConfig.cs | 2 +- .../SequenceErrorException.cs | 2 +- .../ShareCore.cs | 6 +-- .../SingleAssignmentDisposable.cs | 2 +- .../Subjects/AsyncSubject.cs | 2 +- .../Subjects/BehaviorSubject.cs | 2 +- .../Subjects/ReplaySubject.cs | 2 +- .../Subjects/Subject.cs | 6 +-- .../Subscriber.cs | 4 +- .../Subscription.cs | 2 +- .../TaskPoolScheduler.cs | 2 +- .../Testing/MarbleParser.cs | 2 +- .../Testing/Recorded.cs | 2 +- .../Testing/RecordedKind.cs | 2 +- .../Testing/TestScheduler.cs | 4 +- .../Testing/VirtualTimeScheduler.cs | 2 +- .../TimeInterval.cs | 2 +- .../Timestamp.cs | 2 +- .../Unit.cs | 2 +- .../UnsubscriptionException.cs | 2 +- .../stylecop.json | 0 .../AsyncBridgeTests.cs | 2 +- .../BindCallbackTests.cs | 2 +- .../BindNodeCallbackTests.cs | 2 +- .../CombineLatestTests.cs | 8 +-- .../Extras/AssumeNeverEmitsExtrasTests.cs | 4 +- .../Extras/CancellationExtrasTests.cs | 4 +- .../Extras/FilterAsyncExtrasTests.cs | 4 +- .../Extras/FromEventBufferedExtrasTests.cs | 4 +- .../Extras/TimeoutExtrasTests.cs | 4 +- .../ForkJoinTests.cs | 4 +- .../MergeTests.cs | 6 +-- .../Observable.CreationTests.cs | 16 +++--- .../ObservableTests.cs | 2 +- .../Operators/AuditTests.cs | 6 +-- .../Operators/AuditTimeTests.cs | 6 +-- .../Operators/BufferCountTests.cs | 4 +- .../Operators/BufferTests.cs | 6 +-- .../Operators/BufferTimeTests.cs | 6 +-- .../Operators/BufferWhenTests.cs | 6 +-- .../Operators/CatchErrorTests.cs | 4 +- .../Operators/CombineLatestAllTests.cs | 4 +- .../Operators/CombineLatestWithTests.cs | 6 +-- .../Operators/ConcatAllTests.cs | 4 +- .../Operators/ConcatMapTests.cs | 6 +-- .../Operators/ConcatMapToTests.cs | 4 +- .../Operators/ConcatWithTests.cs | 4 +- .../Operators/CountTests.cs | 6 +-- .../Operators/DebounceTests.cs | 6 +-- .../Operators/DebounceTimeTests.cs | 8 +-- .../Operators/DefaultIfEmptyTests.cs | 4 +- .../Operators/DelayTests.cs | 6 +-- .../Operators/DelayWhenTests.cs | 6 +-- .../Operators/DisposalCascadeTests.cs | 4 +- .../Operators/DistinctTests.cs | 6 +-- .../Operators/DistinctUntilChangedTests.cs | 6 +-- .../Operators/DistinctUntilKeyChangedTests.cs | 4 +- .../Operators/ElementAtTests.cs | 6 +-- .../Operators/EndWithTests.cs | 4 +- .../Operators/EveryTests.cs | 6 +-- .../Operators/ExhaustAllTests.cs | 6 +-- .../Operators/ExhaustMapTests.cs | 6 +-- .../Operators/ExpandTests.cs | 4 +- .../Operators/FilterTests.cs | 4 +- .../Operators/FinalizeTests.cs | 4 +- .../Operators/FindIndexTests.cs | 6 +-- .../Operators/FindTests.cs | 6 +-- .../Operators/FirstTests.cs | 6 +-- .../Operators/GroupByTests.cs | 8 +-- .../Operators/IgnoreElementsTests.cs | 4 +- .../Operators/IsEmptyTests.cs | 8 +-- .../Operators/LastTests.cs | 6 +-- .../Operators/MapTests.cs | 4 +- .../Operators/MapToTests.cs | 4 +- .../Operators/MaterializeTests.cs | 4 +- .../Operators/MaxTests.cs | 4 +- .../Operators/MergeAllTests.cs | 6 +-- .../Operators/MergeMapTests.cs | 8 +-- .../Operators/MergeMapToTests.cs | 4 +- .../Operators/MergeScanTests.cs | 4 +- .../Operators/MergeWithTests.cs | 6 +-- .../Operators/MinTests.cs | 4 +- .../OnErrorResumeNextOperatorTests.cs | 4 +- .../Operators/PairwiseTests.cs | 6 +-- .../Operators/PartitionTests.cs | 8 +-- .../Operators/RaceWithTests.cs | 6 +-- .../Operators/ReduceTests.cs | 4 +- .../Operators/RepeatTests.cs | 6 +-- .../Operators/RepeatWhenTests.cs | 6 +-- .../Operators/RetryTests.cs | 8 +-- .../Operators/RetryWhenTests.cs | 6 +-- .../Operators/SampleTests.cs | 6 +-- .../Operators/SampleTimeTests.cs | 6 +-- .../Operators/ScanTests.cs | 4 +- .../Operators/SequenceEqualTests.cs | 8 +-- .../Operators/ShareReplayTests.cs | 8 +-- .../Operators/ShareTests.cs | 8 +-- .../Operators/SingleTests.cs | 4 +- .../Operators/SkipLastTests.cs | 4 +- .../Operators/SkipTests.cs | 4 +- .../Operators/SkipUntilTests.cs | 6 +-- .../Operators/SkipWhileTests.cs | 4 +- .../Operators/StartWithTests.cs | 4 +- .../Operators/SwitchAllTests.cs | 6 +-- .../Operators/SwitchMapTests.cs | 6 +-- .../Operators/SwitchMapToTests.cs | 6 +-- .../Operators/SwitchScanTests.cs | 6 +-- .../Operators/TakeLastTests.cs | 4 +- .../Operators/TakeTests.cs | 8 +-- .../Operators/TakeUntilTests.cs | 6 +-- .../Operators/TakeWhileTests.cs | 4 +- .../Operators/TapTests.cs | 4 +- .../Operators/ThrottleTests.cs | 6 +-- .../Operators/ThrottleTimeTests.cs | 6 +-- .../Operators/ThrowIfEmptyTests.cs | 4 +- .../Operators/TimeIntervalTests.cs | 8 +-- .../Operators/TimestampTests.cs | 8 +-- .../Operators/ToArrayTests.cs | 6 +-- .../Operators/WindowCountTests.cs | 4 +- .../Operators/WindowTests.cs | 6 +-- .../Operators/WindowTimeTests.cs | 10 ++-- .../Operators/WindowWhenTests.cs | 6 +-- .../Operators/WithLatestFromTests.cs | 6 +-- .../Operators/ZipAllTests.cs | 4 +- .../Operators/ZipWithTests.cs | 4 +- .../RaceWithSignalAndTimerTests.cs | 6 +-- .../RetryAndRaceWithSignalAndTimerTests.cs | 4 +- .../ReactiveExtensionsSharp.Tests.csproj} | 2 +- .../RxConfigTests.cs | 2 +- .../Samples/PipeSample.cs | 4 +- .../Samples/QuickTasteSample.cs | 4 +- .../Samples/RetryUntilTimeoutSample.cs | 4 +- .../Subjects/AsyncSubjectTests.cs | 4 +- .../Subjects/BehaviorSubjectTests.cs | 6 +-- .../Subjects/ReplaySubjectTests.cs | 4 +- .../Subjects/SubjectTests.cs | 6 +-- .../SubscriberTests.cs | 2 +- .../SubscriptionTests.cs | 2 +- .../TestObserver.cs | 2 +- .../Testing/TestSchedulerTests.cs | 4 +- .../Testing/VirtualTimeSchedulerTests.cs | 4 +- .../ZipTests.cs | 4 +- 257 files changed, 555 insertions(+), 555 deletions(-) rename RxSharp.sln => ReactiveExtensionsSharp.sln (88%) rename src/{RxSharp => ReactiveExtensionsSharp}/AsyncBridge.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/EmptyErrorException.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/AssumeNeverEmits.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/FilterAsync.cs (94%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/FromCancellationToken.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/FromEventBuffered.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/RaceWithSignalAndTimer.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/RetryAndRaceWithSignalAndTimer.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Extras/Timeout.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/GroupedObservable.cs (93%) rename src/{RxSharp => ReactiveExtensionsSharp}/IGroupedObservable.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/IScheduler.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/NotFoundErrorException.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Notification.cs (91%) rename src/{RxSharp => ReactiveExtensionsSharp}/Observable.Creation.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Observable.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/OperatorFunction.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Audit.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Buffer.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/BufferCount.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/BufferTime.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/BufferWhen.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/CatchError.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/CombineLatestAll.cs (76%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/CombineLatestWith.cs (83%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ConcatAll.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ConcatMap.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ConcatMapTo.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ConcatWith.cs (85%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Count.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Debounce.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/DebounceTime.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/DefaultIfEmpty.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Delay.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/DelayWhen.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Distinct.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/DistinctUntilChanged.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ElementAt.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/EndWith.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Every.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ExhaustAll.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ExhaustMap.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Expand.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Filter.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Finalize.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Find.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/FindIndex.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/First.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/GroupBy.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/IgnoreElements.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/IsEmpty.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Last.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Map.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MapTo.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Materialize.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Max.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MergeAll.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MergeMap.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MergeMapTo.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MergeScan.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/MergeWith.cs (85%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Min.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/OnErrorResumeNext.cs (86%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Pairwise.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Partition.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Race.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Reduce.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Repeat.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/RepeatWhen.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Retry.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/RetryWhen.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Sample.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Scan.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SequenceEqual.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Share.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ShareConfig.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ShareReplay.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Single.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Skip.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SkipLast.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SkipUntil.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SkipWhile.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/StartWith.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SwitchAll.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SwitchMap.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SwitchMapTo.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/SwitchScan.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Take.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/TakeLast.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/TakeUntil.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/TakeWhile.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Tap.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Throttle.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ThrowIfEmpty.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/TimeInterval.cs (87%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Timestamp.cs (83%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ToArray.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/Window.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/WindowCount.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/WindowTime.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/WindowWhen.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/WithLatestFrom.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ZipAll.cs (69%) rename src/{RxSharp => ReactiveExtensionsSharp}/Operators/ZipWith.cs (80%) rename src/{RxSharp => ReactiveExtensionsSharp}/RaceCore.cs (98%) rename src/{RxSharp/RxSharp.csproj => ReactiveExtensionsSharp/ReactiveExtensionsSharp.csproj} (94%) rename src/{RxSharp => ReactiveExtensionsSharp}/RxConfig.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/SequenceErrorException.cs (95%) rename src/{RxSharp => ReactiveExtensionsSharp}/ShareCore.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/SingleAssignmentDisposable.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subjects/AsyncSubject.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subjects/BehaviorSubject.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subjects/ReplaySubject.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subjects/Subject.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subscriber.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/Subscription.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/TaskPoolScheduler.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/Testing/MarbleParser.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Testing/Recorded.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/Testing/RecordedKind.cs (90%) rename src/{RxSharp => ReactiveExtensionsSharp}/Testing/TestScheduler.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Testing/VirtualTimeScheduler.cs (99%) rename src/{RxSharp => ReactiveExtensionsSharp}/TimeInterval.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Timestamp.cs (98%) rename src/{RxSharp => ReactiveExtensionsSharp}/Unit.cs (97%) rename src/{RxSharp => ReactiveExtensionsSharp}/UnsubscriptionException.cs (96%) rename src/{RxSharp => ReactiveExtensionsSharp}/stylecop.json (100%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/AsyncBridgeTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/BindCallbackTests.cs (99%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/BindNodeCallbackTests.cs (99%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/CombineLatestTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Extras/AssumeNeverEmitsExtrasTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Extras/CancellationExtrasTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Extras/FilterAsyncExtrasTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Extras/FromEventBufferedExtrasTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Extras/TimeoutExtrasTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/ForkJoinTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/MergeTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Observable.CreationTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/ObservableTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/AuditTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/AuditTimeTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/BufferCountTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/BufferTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/BufferTimeTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/BufferWhenTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/CatchErrorTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/CombineLatestAllTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/CombineLatestWithTests.cs (88%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ConcatAllTests.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ConcatMapTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ConcatMapToTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ConcatWithTests.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/CountTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DebounceTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DebounceTimeTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DefaultIfEmptyTests.cs (91%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DelayTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DelayWhenTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DisposalCascadeTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DistinctTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DistinctUntilChangedTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/DistinctUntilKeyChangedTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ElementAtTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/EndWithTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/EveryTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ExhaustAllTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ExhaustMapTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ExpandTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/FilterTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/FinalizeTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/FindIndexTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/FindTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/FirstTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/GroupByTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/IgnoreElementsTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/IsEmptyTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/LastTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MapTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MapToTests.cs (91%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MaterializeTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MaxTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MergeAllTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MergeMapTests.cs (91%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MergeMapToTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MergeScanTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MergeWithTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/MinTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/OnErrorResumeNextOperatorTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/PairwiseTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/PartitionTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/RaceWithTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ReduceTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/RepeatTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/RepeatWhenTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/RetryTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/RetryWhenTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SampleTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SampleTimeTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ScanTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SequenceEqualTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ShareReplayTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ShareTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SingleTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SkipLastTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SkipTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SkipUntilTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SkipWhileTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/StartWithTests.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SwitchAllTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SwitchMapTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SwitchMapToTests.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/SwitchScanTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TakeLastTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TakeTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TakeUntilTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TakeWhileTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TapTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ThrottleTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ThrottleTimeTests.cs (96%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ThrowIfEmptyTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TimeIntervalTests.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/TimestampTests.cs (89%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ToArrayTests.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/WindowCountTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/WindowTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/WindowTimeTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/WindowWhenTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/WithLatestFromTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ZipAllTests.cs (93%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Operators/ZipWithTests.cs (91%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs (97%) rename test/{RxSharp.Tests/RxSharp.Tests.csproj => ReactiveExtensionsSharp.Tests/ReactiveExtensionsSharp.Tests.csproj} (89%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/RxConfigTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Samples/PipeSample.cs (90%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Samples/QuickTasteSample.cs (94%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Samples/RetryUntilTimeoutSample.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Subjects/AsyncSubjectTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Subjects/BehaviorSubjectTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Subjects/ReplaySubjectTests.cs (97%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Subjects/SubjectTests.cs (95%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/SubscriberTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/SubscriptionTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/TestObserver.cs (92%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Testing/TestSchedulerTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/Testing/VirtualTimeSchedulerTests.cs (98%) rename test/{RxSharp.Tests => ReactiveExtensionsSharp.Tests}/ZipTests.cs (98%) diff --git a/.github/workflows/publish-nuget.yml b/.github/workflows/publish-nuget.yml index 156e3c6..0b5d3e7 100644 --- a/.github/workflows/publish-nuget.yml +++ b/.github/workflows/publish-nuget.yml @@ -27,7 +27,7 @@ jobs: run: dotnet restore - name: Build - run: dotnet build src/RxSharp/RxSharp.csproj --configuration Release --no-restore + run: dotnet build src/ReactiveExtensionsSharp/ReactiveExtensionsSharp.csproj --configuration Release --no-restore # Trusted Publishing (https://learn.microsoft.com/en-us/nuget/nuget-org/trusted-publishing): exchanges a # short-lived GitHub OIDC token for a temporary NuGet API key, valid 1 hour, instead of storing a long-lived @@ -40,4 +40,4 @@ jobs: user: ${{ secrets.NUGET_USER }} - name: Push to nuget.org - run: dotnet nuget push ./src/RxSharp/bin/Release/*.nupkg --api-key ${{ steps.nuget-login.outputs.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate + run: dotnet nuget push ./src/ReactiveExtensionsSharp/bin/Release/*.nupkg --api-key ${{ steps.nuget-login.outputs.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate diff --git a/CLAUDE.md b/CLAUDE.md index d525970..921f91d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,6 +1,6 @@ -# RxSharp +# ReactiveExtensionsSharp -A .NET port of RxJS. C# namespace: `RxSharp`. NuGet PackageId: `ReactiveExtensionsSharp` (the plain `RxSharp` package name was already taken on nuget.org). GitHub repo: `hardkoded/ReactiveExtensions-Sharp` (directory on disk may still be named `rxjs-sharp`). +A .NET port of RxJS. C# namespace: `ReactiveExtensionsSharp`. NuGet PackageId: `ReactiveExtensionsSharp` (the plain `ReactiveExtensionsSharp` package name was already taken on nuget.org). GitHub repo: `hardkoded/ReactiveExtensions-Sharp` (directory on disk may still be named `rxjs-sharp`). ## Why this exists @@ -16,9 +16,9 @@ Upstream Puppeteer (JS) uses rxjs internally for timeout/retry/cancellation comb # ... read files under /tmp/rxjs-782-ref/spec/ ... git -C /Users/dario/Code/reactivex/rxjs worktree remove /tmp/rxjs-782-ref ``` -- **Puppeteer usage must show up in tests, not just a one-off playground check**: `test/RxSharp.Tests/PuppeteerScenarios/` holds hand-written cases (no upstream spec equivalent) modeled on real Puppeteer usage patterns — see list below. These run in normal CI, independent of any one-time validation against the real puppeteer-sharp codebase. +- **Puppeteer usage must show up in tests, not just a one-off playground check**: `test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/` holds hand-written cases (no upstream spec equivalent) modeled on real Puppeteer usage patterns — see list below. These run in normal CI, independent of any one-time validation against the real puppeteer-sharp codebase. - **Keep this file current**: update it with learnings as milestones land — API decisions that changed, gotchas found while porting upstream tests, anything a future session would otherwise have to rediscover. -- **README sells it**: runnable example, RxJS→RxSharp comparison snippet, badges, roadmap/parity status — not a dry stub. +- **README sells it**: runnable example, RxJS→ReactiveExtensionsSharp comparison snippet, badges, roadmap/parity status — not a dry stub. ## Conventions @@ -28,8 +28,8 @@ Upstream Puppeteer (JS) uses rxjs internally for timeout/retry/cancellation comb - `TreatWarningsAsErrors=true` via root `Directory.Build.props`. - XML-doc completeness (`CS1591`, `SA160x`) is suppressed for now — deferred to the M4 docs pass, not worth blocking TDD cycles on it while the API is still moving. - Test framework: NUnit + NUnit.Analyzers + NUnit3TestAdapter + NSubstitute (matches puppeteer-sharp's test stack). -- Layout is flat (`src/RxSharp/`, `test/RxSharp.Tests/`) at repo root, not nested under `lib/` like puppeteer-sharp — no samples/demos/docfx yet to justify that nesting. Revisit if the project grows to match that scope. -- One file per operator under `src/RxSharp/Operators/` (mirrors rxjs's own layout; also satisfies StyleCop's one-type-per-file rule for free). +- Layout is flat (`src/ReactiveExtensionsSharp/`, `test/ReactiveExtensionsSharp.Tests/`) at repo root, not nested under `lib/` like puppeteer-sharp — no samples/demos/docfx yet to justify that nesting. Revisit if the project grows to match that scope. +- One file per operator under `src/ReactiveExtensionsSharp/Operators/` (mirrors rxjs's own layout; also satisfies StyleCop's one-type-per-file rule for free). ## Core design @@ -50,7 +50,7 @@ Puppeteer funnels all its rxjs usage through one wrapper file re-exporting ~40 s - Creation: `of`, `from`, `defer`, `fromEvent`, `timer`, `concat`, `merge`, `race`, `raceWith`, `zip`, `forkJoin`, `combineLatest`, `EMPTY`, `NEVER`, `identity`, `noop` - Async bridge: `firstValueFrom`, `lastValueFrom` - Operators: `map`, `filter`, `mergeMap`, `concatMap`, `switchMap`, `mergeScan`, `bufferCount`, `take`, `first`, `takeUntil`, `startWith`, `distinctUntilChanged`, `defaultIfEmpty`, `throwIfEmpty`, `ignoreElements`, `debounceTime`, `delay`, `delayWhen`, `retry`, `catchError`, `tap` -- Custom combinators to replicate in `RxSharp.Extras`: `fromEmitterEvent` (done, as `Observable.FromEvent` — see Core design), `fromAbortSignal` → `FromCancellationToken` (done), `timeout` (done), `filterAsync` (done), `retryAndRaceWithSignalAndTimer` (done — `retry` + `raceWith(fromCancellationToken, timeout)`, the combinator behind Puppeteer's `Locator` actions) +- Custom combinators to replicate in `ReactiveExtensionsSharp.Extras`: `fromEmitterEvent` (done, as `Observable.FromEvent` — see Core design), `fromAbortSignal` → `FromCancellationToken` (done), `timeout` (done), `filterAsync` (done), `retryAndRaceWithSignalAndTimer` (done — `retry` + `raceWith(fromCancellationToken, timeout)`, the combinator behind Puppeteer's `Locator` actions) **The entire Puppeteer-essential list is now implemented.** `Zip`/`ForkJoin`/`CombineLatest` are same-type-array-only for now (see Core design) rather than rxjs's heterogeneously-typed tuple overloads. M2's remaining work is optional breadth beyond this list, toward the "broad RxJS parity" ambition. @@ -58,7 +58,7 @@ Formerly-low-priority items now done across M4/M5/M7: `debounce`/`audit`/`sample ## Milestones -See the original plan for full detail. Summary: M0 scaffolding (done) → M1 core engine + first operator slice (done) → M2 broad operator/creation-function expansion + `RxSharp.Extras` + `PuppeteerScenarios` tests (done: the entire Puppeteer-essential surface is implemented — scheduler seam, all creation functions, all listed operators, `RxSharp.Extras`, and the end-to-end `RetryAndRaceWithSignalAndTimer` test) → M3 playground validation against a throwaway branch of puppeteer-sharp (done, see below) → M4 long tail (schedulers, marble testing, docs/CI polish, remaining full-parity operators beyond the essential list). +See the original plan for full detail. Summary: M0 scaffolding (done) → M1 core engine + first operator slice (done) → M2 broad operator/creation-function expansion + `ReactiveExtensionsSharp.Extras` + `PuppeteerScenarios` tests (done: the entire Puppeteer-essential surface is implemented — scheduler seam, all creation functions, all listed operators, `ReactiveExtensionsSharp.Extras`, and the end-to-end `RetryAndRaceWithSignalAndTimer` test) → M3 playground validation against a throwaway branch of puppeteer-sharp (done, see below) → M4 long tail (schedulers, marble testing, docs/CI polish, remaining full-parity operators beyond the essential list). **M3 result**: a git worktree at `/Users/dario/Code/hardkoded/puppeteer-sharp-rx-playground` (branch `experiment/rxjs-sharp-playground`, off `origin/master`, local-only/unpushed) with a throwaway `lib/PuppeteerSharp.RxPlayground.Tests/` project (not in `PuppeteerSharp.sln`, not wired into CI). All 4 tests pass against a real launched Chrome (auto-downloaded via `BrowserFetcher` in a `[SetUpFixture]`, same pattern puppeteer-sharp's own test suite uses): a `Locator`-style click helper built entirely from `Observable.Defer` + `RetryAndRaceWithSignalAndTimer` retries until a delayed-appearing element exists and clicks it, and correctly times out with `TimeoutException` when the element never appears; `Observable.FromEvent` correctly wraps both a real `EventHandler` event (`IPage.Console`) and a real plain `EventHandler` event (`IPage.Load`). This is real end-to-end proof the port's API works for its intended purpose, not just synthetic unit tests. @@ -76,7 +76,7 @@ GitHub remote is live as of this milestone: `https://github.com/hardkoded/Reacti **M7 done**: the remaining "rarely-used creation functions" from the parity gap list, parallelized across 3 worktree agents. Landed: `Partition` (delegates to two independent `Filter` subscriptions, matching rxjs's actual `partition.ts`, verified against the 7.8.2 tag rather than assumed); `BindCallback`/`BindNodeCallback` (0-3 arity overloads, `AsyncSubject`-backed caching so the wrapped function is invoked once and replayed to later subscribers, ported near-literally from rxjs's `bindCallbackInternals` including its `isAsync`/`isComplete` flag dance for synchronous-callback-then-throw edge cases); `Using` (per-subscription resource + source factory, resource disposed on complete/error/unsubscribe, requires `IDisposable` rather than rxjs's structural `Unsubscribable`); `OnErrorResumeNext` (sequences sources, advancing on error OR complete unlike `Concat`, deliberately NOT using rxjs's own "resubscribe via a teardown action" trick since that would incorrectly advance on a plain external unsubscribe too — see the XML doc remarks on `Observable.OnErrorResumeNext` for the full reasoning). 644 tests passing on `main`. This closes out the entire "broad RxJS parity" list from M2's Puppeteer-essential-surface note except the explicitly-optional `Scheduler`/`Action` hierarchy and standalone `connectable`/`publish`/`refCount`. -**M8 done**: a systematic test-coverage audit (a background agent compared every RxSharp test file against its upstream rxjs 7.8.2 spec file) turned up a real punch list — missing operators, thin test coverage on Puppeteer-essential operators, and (unexpectedly) several genuine bugs — closed via 6 parallel worktree agents. 825 tests passing on `main` at the end. Landed: +**M8 done**: a systematic test-coverage audit (a background agent compared every ReactiveExtensionsSharp test file against its upstream rxjs 7.8.2 spec file) turned up a real punch list — missing operators, thin test coverage on Puppeteer-essential operators, and (unexpectedly) several genuine bugs — closed via 6 parallel worktree agents. 825 tests passing on `main` at the end. Landed: - **New operators**: `Finalize` (try/finally equivalent; subscribes the source with the exact downstream subscriber, no wrapper, so it never introduces the disposal-cascade gap in the first place), `RepeatWhen` (the `Repeat`-family counterpart to `RetryWhen`), `SkipLast`/`SkipUntil`/`Expand`/`Max`/`Min`/`EndWith`, and a long tail of alias/higher-order operators: `MergeAll`/`ConcatAll`/`ExhaustAll`/`SwitchAll` (identity-projected `*Map` delegations), `CombineLatestAll`/`ZipAll` (`ToArray().MergeMap(sources => Combine/Zip(sources))`, rxjs's own `joinAllInternals` pattern), `MapTo`/`MergeMapTo`/`ConcatMapTo`/`SwitchMapTo` (deprecated upstream, still in 7.8.2), `ConcatWith`/`MergeWith`/`CombineLatestWith`/`ZipWith`/pipeable `OnErrorResumeNext` (prepend-source sugar over the existing creation functions), `SwitchScan` (`MergeScan` + `SwitchMap`'s switch behavior), and `TimeInterval`/`Timestamp` (two new core value types, using `IScheduler.Now` so a `TestScheduler` can drive them deterministically in tests). - **Feature completions**: `Retry`/`Repeat` gained a notifier-selector-based delay overload alongside the existing fixed-`TimeSpan` one (rxjs's `RetryConfig`/`RepeatConfig` split into two overloads rather than one config object), plus `Retry`'s `resetOnSuccess` flag; `Share` gained a `ShareConfig` overload (`resetOnError`/`resetOnComplete`/`resetOnRefCountZero`/custom `connector`), matching rxjs's defaults exactly for the existing no-config overload's unchanged behavior. - **Real bugs found and fixed, independent of the coverage gaps being closed** (this is the most important outcome of M8 — the audit was meant to find missing tests, but writing them surfaced actual correctness bugs): @@ -103,11 +103,11 @@ GitHub remote is live as of this milestone: `https://github.com/hardkoded/Reacti - **`SwitchMap` is the one operator so far where the "`SingleAssignmentDisposable` never disposes what it's replacing" limitation (see above) actually bites**: switching to a new inner observable must tear down the *still-live* previous inner, unlike `Take`/`First`/`CatchError`/`Retry` where the thing being replaced has always already self-torn-down by the time of reassignment. Fixed by explicitly calling `innerSubscription.Disposable?.Dispose()` right before assigning the new one. Caught by a test asserting a value pushed into the abandoned inner after switching never reaches the subscriber — don't skip that kind of test for future switch-like operators (`exhaustMap`, `switchScan`, ...). - **`Delay` cannot be built on `DelayWhen`/`MergeMap`** the way rxjs implements it, despite that being the obviously elegant reuse — `MergeMap` subscribes to one independent `Timer` per value *concurrently*, and `TaskPoolScheduler`'s real, thread-pool-backed timers don't guarantee same-duration timers fire back in scheduling order. A synchronous burst (`Of(1,2,3).Delay(20ms)`) came back as `[3,1,2]` in a test run. Fixed by giving `Delay` its own single-queue implementation (only one timer ever active, always for the queue head) — see `Operators/Delay.cs` for the tradeoff this introduces (delays stack under bursts rather than each item getting a uniform per-arrival offset). **Lesson: any future operator built from `MergeMap`/`Race`/concurrent-timer composition needs an explicit ordering test, not just a values-are-eventually-correct test** — this bug would not have been caught by an `Is.EquivalentTo` assertion, only by `Is.EqualTo` checking order. - **Parallelizing M4 across isolated worktrees off the same base commit means the "remove doc-completeness NoWarn suppressions" branch and every branch that added new files raced each other.** The docs-pass branch only added docs to files that existed *when it was created* — any file added by a sibling branch (`Testing/*.cs` from the scheduler workstream, `GroupBy.cs`/`Audit.cs`/etc. from the grouping workstream) had no docs at all, so once both were merged into `main` (NoWarn suppressions gone, undocumented new files present), the build broke. Fixed by hand after each merge rather than re-suppressing. **Lesson: when parallelizing a "remove a project-wide suppression" task alongside other code-adding tasks, either land the suppression-removal branch dead last, or budget an integration pass to add docs to whatever landed in between** — this isn't specific to docs, it'll happen with any project-wide-enforcement change parallelized against feature branches. -- **RESOLVED (Take/First's own case) but BROADER THAN FIRST THOUGHT — systemic gap, partially addressed, not fully closed.** rxjs's own "should stop listening to a synchronous observable when unsubscribed" test (a hand-rolled source loops `for (i = 0; !subscriber.closed && i < 10; i++) { sideEffects.push(i); subscriber.next(i); }`) genuinely failed in RxSharp for `Take`/`First` alone. **Root cause**: their internal subscription to the source was `sourceSubscription.Disposable = src.Subscribe(onNext: ...)` (a `SingleAssignmentDisposable` wrapping the *return value* of `Subscribe`), with `sourceSubscription.Dispose()` called from *inside* that same `onNext` callback once the count was reached — but for a fully-synchronous source, the whole loop runs to completion *before* `Subscribe` returns, so `sourceSubscription.Disposable` is still unassigned at the moment `.Dispose()` is called; the real inner `Subscriber` the source loop actually checks `.IsDisposed` on isn't created/disposed until too late. Contrast with real rxjs: a newly-constructed operator `Subscriber` registers itself as a child of its *destination* subscriber immediately at construction (`destination.add(this)`), before the source is ever subscribed to, so a downstream `complete()`/`unsubscribe()` cascades down synchronously even mid-loop. **Fix applied to `Take`/`First`/`ShareCore`**: build the inner `Subscriber` directly via `Subscriber.Create(...)` into a local variable *before* calling `src.Subscribe(...)`. +- **RESOLVED (Take/First's own case) but BROADER THAN FIRST THOUGHT — systemic gap, partially addressed, not fully closed.** rxjs's own "should stop listening to a synchronous observable when unsubscribed" test (a hand-rolled source loops `for (i = 0; !subscriber.closed && i < 10; i++) { sideEffects.push(i); subscriber.next(i); }`) genuinely failed in ReactiveExtensionsSharp for `Take`/`First` alone. **Root cause**: their internal subscription to the source was `sourceSubscription.Disposable = src.Subscribe(onNext: ...)` (a `SingleAssignmentDisposable` wrapping the *return value* of `Subscribe`), with `sourceSubscription.Dispose()` called from *inside* that same `onNext` callback once the count was reached — but for a fully-synchronous source, the whole loop runs to completion *before* `Subscribe` returns, so `sourceSubscription.Disposable` is still unassigned at the moment `.Dispose()` is called; the real inner `Subscriber` the source loop actually checks `.IsDisposed` on isn't created/disposed until too late. Contrast with real rxjs: a newly-constructed operator `Subscriber` registers itself as a child of its *destination* subscriber immediately at construction (`destination.add(this)`), before the source is ever subscribed to, so a downstream `complete()`/`unsubscribe()` cascades down synchronously even mid-loop. **Fix applied to `Take`/`First`/`ShareCore`**: build the inner `Subscriber` directly via `Subscriber.Create(...)` into a local variable *before* calling `src.Subscribe(...)`. **Then a sharper finding while porting `Skip`/`SkipWhile`**: the SAME failure reproduces for `Filter().Take()` — i.e. *any* plain pass-through operator (`Map`, `Filter`, `Tap`, `StartWith`, `DistinctUntilChanged`, ...) sitting between a synchronous source and an early-completing downstream operator (`Take`, `First`, `TakeWhile`, `Skip`, ...) also fails to cascade the stop, because it never checks whether forwarding a value just caused its *own* downstream subscriber to become disposed. This is NOT limited to operators that complete on their own — it's about every intermediate link in the chain needing to notice "did forwarding this value dispose whoever I'm forwarding *to*?" and, if so, immediately tear down its *own* upstream subscription too. `Skip`/`SkipWhile` were given this cooperation explicitly (check `subscriber.IsDisposed` right after every forward, cascade-dispose the inner subscriber if so — see `Skip.cs`) since their own ported tests required it. **`Map`/`Filter`/`Tap`/`StartWith`/`DistinctUntilChanged`/`DefaultIfEmpty`/`ThrowIfEmpty`/`IgnoreElements` were NOT retrofitted with this check** — confirmed vulnerable, deliberately left as-is to avoid a sweeping, risky change under time pressure, but this is real debt. **The actually-correct general fix** (verified by hand-tracing, NOT yet applied broadly — see the risk finding below for why): register a newly-created internal `Subscriber` as a child of the *downstream* subscriber via `downstreamSubscriber.Add(innerSubscriber)` immediately after construction, *before* calling `src.Subscribe(innerSubscriber)` — mirroring rxjs's `destination.add(this)` at construction time. Since `Subscriber.OnCompleted`/`OnError` already call `Unsubscribe()` (= `Dispose()`) on themselves in a `finally` block, this one change makes ANY downstream completion/error/disposal automatically cascade up through the whole chain via the ordinary `Subscription` child-finalizer mechanism — no per-operator "check IsDisposed after every forward" boilerplate needed anywhere. Hand-traced end-to-end for `Of(1..10).Map(x=>x).Take(3)` with this fix applied to *both* `Map` and `Take`: disposing the terminal subscriber at `seen>=3` correctly cascades child-by-child all the way up to the `Of`/`From` loop's own `IsDisposed` check, stopping it after exactly 3 iterations — confirmed correct, not just plausible. The literal ported synchronous-source tests for `Take`/`First`/`Skip`/`SkipWhile`/`Distinct` are permanent regression coverage — don't remove them, and add one for any new operator in this same shape. A third independent M5 agent reconfirmed the exact same root cause with `Map().Take()` (see the set/predicate/aggregation slice) — three separate confirmations now, not a fluke. **The risk that split this into two parts.** `Subscription` doesn't implement the "a child removes itself from its parent's finalizer list when it disposes independently" behavior real rxjs has (this was explicitly skipped back in M1 as "not essential" — see the original `Subscription-spec.ts` port). For an operator with exactly ONE stable inner subscription for its whole lifetime, `subscriber.Add(innerSubscriber)` once is completely safe — nothing ever needs removing early. But for an operator that creates a NEW inner subscription per value or per cycle and expects the old one to just get garbage collected once it completes on its own (`MergeMap`, `ConcatMap`, `SwitchMap`, `ExhaustMap`, `MergeScan`, `GroupBy`'s per-key groups, `Audit`, `Debounce`, `Sample`, `Throttle`, `Window*`, `Buffer*`'s per-cycle closing notifiers, `Retry`'s per-attempt resubscription, `CatchError`'s replacement-on-error), blindly `Add`-ing each new one without also `subscriber.Remove(...)`-ing it once it completes would make the downstream subscriber's finalizer list grow *unboundedly* for a long-running stream — trading the disposal-cascade bug for a memory leak. - **Part (1) DONE (M6).** Added `OperatorHelper.SubscribeChild(this Observable source, Subscriber downstream, Action? onNext, Action? onError, Action? onComplete)` in `src/RxSharp/OperatorFunction.cs` — builds the inner `Subscriber` via `Subscriber.Create(...)`, calls `downstream.Add(innerSubscriber)` *before* subscribing, then returns `null` (see the double-add finding right below for why it's `null` and not the inner subscriber). Its doc comment repeats the "only for a single stable inner subscription" caveat so it can't be reached for by future per-cycle operators without reading why. Applied to all 17 "single stable inner subscription" operators: `Map`, `Filter`, `Tap`, `StartWith`, `DistinctUntilChanged`, `DefaultIfEmpty`, `ThrowIfEmpty`, `IgnoreElements`, `TakeUntil`, `TakeLast`, `Count`, `ToArray`, `Materialize`, `Pairwise`, `Scan`, `Reduce`, `WithLatestFrom` — each just swaps `src.Subscribe(...)` for `src.SubscribeChild(subscriber, ...)`. Regression coverage in `test/RxSharp.Tests/Operators/DisposalCascadeTests.cs` (synchronous self-checking source composed with `Take`, through `Map`/`Filter`/`Tap`/`Scan`/`DistinctUntilChanged`, plus a multi-operator chain). + **Part (1) DONE (M6).** Added `OperatorHelper.SubscribeChild(this Observable source, Subscriber downstream, Action? onNext, Action? onError, Action? onComplete)` in `src/ReactiveExtensionsSharp/OperatorFunction.cs` — builds the inner `Subscriber` via `Subscriber.Create(...)`, calls `downstream.Add(innerSubscriber)` *before* subscribing, then returns `null` (see the double-add finding right below for why it's `null` and not the inner subscriber). Its doc comment repeats the "only for a single stable inner subscription" caveat so it can't be reached for by future per-cycle operators without reading why. Applied to all 17 "single stable inner subscription" operators: `Map`, `Filter`, `Tap`, `StartWith`, `DistinctUntilChanged`, `DefaultIfEmpty`, `ThrowIfEmpty`, `IgnoreElements`, `TakeUntil`, `TakeLast`, `Count`, `ToArray`, `Materialize`, `Pairwise`, `Scan`, `Reduce`, `WithLatestFrom` — each just swaps `src.Subscribe(...)` for `src.SubscribeChild(subscriber, ...)`. Regression coverage in `test/ReactiveExtensionsSharp.Tests/Operators/DisposalCascadeTests.cs` (synchronous self-checking source composed with `Take`, through `Map`/`Filter`/`Tap`/`Scan`/`DistinctUntilChanged`, plus a multi-operator chain). **Part (2) DONE (M6), parallelized across 4 worktree agents.** Every operator on the "per-value/per-cycle inner subscription" list now has both halves of the fix: the child-registration cascade AND the matching `Remove` once that inner subscription naturally ends. Group 1 (mapping-to-observable): `MergeMap`/`ConcatMap`/`MergeScan` build the per-value inner directly and `Remove` it `onComplete`; `SwitchMap`/`ExhaustMap` reuse one `SingleAssignmentDisposable`-style slot for their whole lifetime (added to the downstream once), so switching in a new inner just reassigns the slot — no `Remove` needed there, only the assign-before-subscribe ordering fix. Group 2 (rate-limiting): `Debounce`/`Audit`/`Throttle` rebuild their per-value duration subscriber and `Remove` it when that cycle closes; `Sample`'s notifier turned out to be single-lifetime (no `Remove` needed, direct `SubscribeChild`); `SampleTime`/`DebounceTime` (independent scheduler-based implementations, not built on the non-`Time` variants) get the same Add/Remove treatment for their per-tick scheduled disposable. Group 3 (windowing): `Window`/`Buffer` (single-lifetime boundary/notifier) and `WindowCount`/`BufferCount` (no notifier) just needed the outer-subscription fix; `WindowTime`/`BufferTime`'s per-cycle timers were *already* correctly Added/Removed pre-M6; `WindowWhen`/`BufferWhen` needed both the outer-subscription fix and (new) `Add`/`Remove` on the per-cycle closing-notifier subscriber — previously that notifier was never registered with the downstream `subscriber` at all, only torn down via a bolted-on final `Subscription` wrapper, which is now gone. Group 4 (retry/replace/group): `Retry` gets the per-attempt Add/Remove *and* a previously-missing disposed-check before recursing into the next attempt (a stack-overflow guard, matching `Repeat`/`RetryWhen`'s existing one); `CatchError`'s pre-error source subscription gets the fix, its post-error replacement needs nothing extra since it already reuses the downstream `subscriber` object directly; `GroupBy`'s outer subscription uses `SubscribeChild` directly, and its per-key duration-notifier subscriber gets Add-before-subscribe + `Remove` in `CloseGroup()` — the trickiest case since group cardinality (and therefore notifier count) can be unbounded. 602 tests green after all four merges (up from 573). **A new, distinct bug found while wiring this up: `SubscribeChild` was double-registering its own inner subscriber.** Since it already calls `downstream.Add(innerSubscriber)` internally, every call site written as `return src.SubscribeChild(...)` (the tail expression of an `Operate` callback) let that same object flow back up through `Observable.Subscribe`, which *also* adds whatever the callback returns as a teardown (`if (teardown is not null) { ... subscriber.Add(teardown); }`) — registering the identical disposable twice in the downstream's finalizer list. Harmless in terms of behavior (disposing a `Subscription` twice is a no-op) but a permanent duplicate entry for the operator's whole lifetime, discovered only because the `GroupBy` agent worked around it empirically (calling `SubscribeChild` as a bare statement and returning `null` explicitly, rather than returning its result) without fully diagnosing why that was necessary. Root-caused and fixed at the source: `SubscribeChild` now always returns `null` instead of the inner subscriber, which silently fixes all ~25 call sites without touching any of them. Regression test: `DisposalCascadeTests.ShouldNotRegisterTheInnerSubscriptionTwice` inspects `Subscription`'s private `_finalizers` list via reflection and asserts exactly one entry — confirmed (by temporarily reverting the fix) that it fails with a count of 2 beforehand. **Lesson: when a helper both performs a side effect (registering a child) AND returns a value that a caller might propagate somewhere that performs the *same* side effect again, that's a real double-registration risk worth tracing through, not dismissing as "should be harmless." Idempotent `Dispose()` papered over the actual bug here for a while.** **A reported `Subject.AsObservable()` leak investigated and NOT confirmed — the code was already correct.** The window/buffer M6 agent flagged `AsObservable() => new Observable(subscriber => Subscribe(subscriber))` as silently picking `Observable`'s `Action>` constructor overload (which discards whatever the delegate returns) instead of the `Func, IDisposable?>` one — which would drop the `RemovalDisposable` that `Subscribe` returns and leak every `AsObservable()` subscriber forever. Investigated by hand-reverting to a byte-for-byte copy of the pre-fix line, deleting `obj`/`bin` to force a clean rebuild (ruling out incremental-build staleness), and running a reflection-based regression test (`SubjectTests.AsObservable_DisposingTheSubscriptionShouldRemoveTheObserverFromTheSubject`, inspecting `Subject`'s private `_observers` list) against that exact original code — it passed. **C# actually resolves the tie correctly**: when a lambda with an expression body is compatible with both an `Action` overload and a `Func` overload of the same arity, the language prefers the `Func` one (the "natural type" with a return value) over silently discarding the return for `Action` — so `AsObservable()` was never broken. Added a one-line comment on `AsObservable()` calling this out explicitly (so a future reader doesn't have to re-derive it) plus the regression test as a permanent guard against a future refactor accidentally landing on the `Action` overload. **Lesson: a background agent's structural/type-system argument for a bug can be wrong even when it sounds plausible and cites real language ambiguity rules — verify with an actual clean-rebuilt failing test before recording something as a confirmed bug in this file, not just before recording something as fixed.** @@ -116,5 +116,5 @@ GitHub remote is live as of this milestone: `https://github.com/hardkoded/Reacti - **`Pairwise` reentrancy bug, found and fixed while porting rxjs's own "recursively re-enterable" test**: it updated its `previous` state slot *before* forwarding the pair downstream instead of *after* — so if the downstream subscriber reacted to a value by synchronously pushing a NEW value back into the (shared, e.g. `Subject`-backed) source from within that same call, the reentrant emission would see an already-updated `previous`, producing a wrong pair. Fixed by capturing/emitting first, updating `previous` last, matching rxjs's own `pairwise.ts` ordering exactly. **General lesson: any operator that carries mutable "previous value" state and calls into a user-supplied downstream synchronously must update that state AFTER forwarding, not before** — same reentrancy-ordering discipline as `DistinctUntilChanged` already follows (check that operator's code for the same "update state, *then* emit" vs. "emit, *then* update" distinction before assuming either order is safe by default). - **`Repeat`/`RetryWhen` needed the Take/First direct-`Subscriber.Create` pattern too, but for a different reason than early-completion**: naively mirroring `Retry.cs`'s recursive-resubscribe structure has two failure modes for a fully-synchronous, repeatedly-completing source — (a) no check for the downstream already being disposed before recursing into the next cycle, a real `StackOverflowException` risk once `count` is large/infinite and downstream is something like `Take`; (b) rxjs's own ported "finalize before starting the next cycle" test can't hold if the next cycle's resubscription happens *inside* the still-executing `Subscribe` call for the current cycle, before that cycle's own teardown had a chance to run. Both fixed with the same direct-`Subscriber.Create`-then-explicit-check-and-`Dispose` technique used for `Take`/`First`, but applied to an "accumulate then recurse" shape rather than a "complete early" one — **this pattern is broader than the name "early-unsubscribe fix" suggests; think of it generically as "always hold a live reference to your own inner subscriber so you can inspect/dispose it synchronously, never rely on `Subscribe`'s return value being assigned in time."** - **`Repeat(0)`/`Repeat(-1)` return `EMPTY` without ever subscribing to the source — `Retry(0)`/`Retry(-1)` still subscribe once.** An easy-to-miss asymmetry between two structurally similar operators; matches rxjs's own actual behavior for each (verified against the spec files, not assumed), so don't "fix" one to match the other. -- **`Notification`** (new core type, `src/RxSharp/Notification.cs`, main `RxSharp` namespace) backs `Materialize`/`Dematerialize` — deliberately NOT a reuse of `RxSharp.Testing.Recorded`, despite the superficial similarity (both tag next/error/complete). `Recorded` carries a virtual-clock timestamp that has no meaning for a core operator, and core operators shouldn't depend on the `RxSharp.Testing` namespace, which exists for tests. Same CA1000 static-factory-on-a-non-generic-sibling pattern as `Recorded`/`Subscriber`. +- **`Notification`** (new core type, `src/ReactiveExtensionsSharp/Notification.cs`, main `ReactiveExtensionsSharp` namespace) backs `Materialize`/`Dematerialize` — deliberately NOT a reuse of `ReactiveExtensionsSharp.Testing.Recorded`, despite the superficial similarity (both tag next/error/complete). `Recorded` carries a virtual-clock timestamp that has no meaning for a core operator, and core operators shouldn't depend on the `ReactiveExtensionsSharp.Testing` namespace, which exists for tests. Same CA1000 static-factory-on-a-non-generic-sibling pattern as `Recorded`/`Subscriber`. - **`WithLatestFrom` subscribes to the "other" observables before the primary source**, matching real rxjs's own subscription order — required for the case where an "other" observable emits synchronously during its own subscribe call, which must be visible by the time the primary source starts emitting. If you add a similar "combine primary + others" operator, check subscription order against the actual rxjs source rather than assuming primary-first is safe. diff --git a/README.md b/README.md index f6a768f..e33af8a 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# RxSharp +# ReactiveExtensionsSharp [![build](https://github.com/hardkoded/ReactiveExtensions-Sharp/actions/workflows/build.yml/badge.svg)](https://github.com/hardkoded/ReactiveExtensions-Sharp/actions/workflows/build.yml) [![NuGet](https://img.shields.io/nuget/v/ReactiveExtensionsSharp.svg)](https://www.nuget.org/packages/ReactiveExtensionsSharp/) @@ -7,7 +7,7 @@ A .NET port of [RxJS](https://rxjs.dev/) — same operators, same semantics, same names you already know, in idiomatic C#. -Why a new Rx library when [Rx.NET](https://github.com/dotnet/reactive) exists? RxSharp isn't trying to replace it — it's a deliberately faithful port of *RxJS specifically*, built to make it painless to bring JS reactive code (and the libraries built on it, like [Puppeteer](https://pptr.dev/)) over to .NET without re-learning a different Rx dialect. If you know `pipe(map(...), filter(...), takeUntil(...))`, you already know RxSharp. +Why a new Rx library when [Rx.NET](https://github.com/dotnet/reactive) exists? ReactiveExtensionsSharp isn't trying to replace it — it's a deliberately faithful port of *RxJS specifically*, built to make it painless to bring JS reactive code (and the libraries built on it, like [Puppeteer](https://pptr.dev/)) over to .NET without re-learning a different Rx dialect. If you know `pipe(map(...), filter(...), takeUntil(...))`, you already know ReactiveExtensionsSharp. ## Quick taste @@ -26,7 +26,7 @@ interval(1000) .subscribe(x => console.log(x)); ``` -Same pipeline in RxSharp — real, compiling code: +Same pipeline in ReactiveExtensionsSharp — real, compiling code: @@ -39,7 +39,7 @@ Observable.Interval(TimeSpan.FromSeconds(1)) .TakeUntil(clicks) .Subscribe(x => Console.WriteLine(x)); ``` -snippet source | anchor +snippet source | anchor ## What about `pipe`? @@ -47,7 +47,7 @@ Observable.Interval(TimeSpan.FromSeconds(1)) RxJS's `pipe(op1, op2, op3)` is mostly just method chaining wearing a different hat — `source.Map(...).Filter(...)` above *is* the translation. But RxJS's `pipe()` has a second job: called on its own (not as an `Observable` method), it builds a **reusable** transformation out of several operators, so you can define it once and apply -it to multiple streams. RxSharp covers that with `OperatorFunction` + `Pipe`: +it to multiple streams. ReactiveExtensionsSharp covers that with `OperatorFunction` + `Pipe`: @@ -62,7 +62,7 @@ public static void Run(Observable numbersA, Observable numbersB) numbersB.Pipe(squareAndFilterEven).Subscribe(x => Console.WriteLine(x)); } ``` -snippet source | anchor +snippet source | anchor There's no hand-written 9-arity `pipe(op1, op2, ..., op9)` overload set, deliberately — it exists in RxJS mainly @@ -79,7 +79,7 @@ don't wait forever." Puppeteer's own .NET port, `puppeteer-sharp`, doesn't have the equivalent logic there is a hand-rolled `while(true)` loop with a linked `CancellationTokenSource` and five `catch` clauses to tell "timed out" apart from "cancelled" apart from "just retry." -RxSharp ports that exact combinator as `RetryAndRaceWithSignalAndTimer`, proven against a real launched Chrome: +ReactiveExtensionsSharp ports that exact combinator as `RetryAndRaceWithSignalAndTimer`, proven against a real launched Chrome: @@ -92,7 +92,7 @@ public static async Task FindElementOnceItRendersAsync(Func .RetryAndRaceWithSignalAndTimer(TimeSpan.FromSeconds(5), cancellationToken) .FirstValueFrom().ConfigureAwait(false); ``` -snippet source | anchor +snippet source | anchor ## Install diff --git a/RxSharp.sln b/ReactiveExtensionsSharp.sln similarity index 88% rename from RxSharp.sln rename to ReactiveExtensionsSharp.sln index 2f6ec77..0059047 100644 --- a/RxSharp.sln +++ b/ReactiveExtensionsSharp.sln @@ -5,11 +5,11 @@ VisualStudioVersion = 17.0.31903.59 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RxSharp", "src\RxSharp\RxSharp.csproj", "{2BE35833-E385-4FE6-9204-30A6BEF96DB6}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReactiveExtensionsSharp", "src\ReactiveExtensionsSharp\ReactiveExtensionsSharp.csproj", "{2BE35833-E385-4FE6-9204-30A6BEF96DB6}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{0C88DD14-F956-CE84-757C-A364CCF449FC}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RxSharp.Tests", "test\RxSharp.Tests\RxSharp.Tests.csproj", "{9A08792D-C101-474F-A5E7-9703A46FCAD5}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReactiveExtensionsSharp.Tests", "test\ReactiveExtensionsSharp.Tests\ReactiveExtensionsSharp.Tests.csproj", "{9A08792D-C101-474F-A5E7-9703A46FCAD5}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/docfx_project/api/index.md b/docfx_project/api/index.md index 716e0f0..50b96e0 100644 --- a/docfx_project/api/index.md +++ b/docfx_project/api/index.md @@ -1,5 +1,5 @@ -# RxSharp API Documentation +# ReactiveExtensionsSharp API Documentation -This section contains the generated API reference for RxSharp, extracted from the XML documentation comments in `src/RxSharp/`. +This section contains the generated API reference for ReactiveExtensionsSharp, extracted from the XML documentation comments in `src/ReactiveExtensionsSharp/`. -Start with [`Observable`](RxSharp.Observable-1.yml) and the static [`Observable`](RxSharp.Observable.yml) factory class for creation functions (`Of`, `From`, `Timer`, `Merge`, ...), then browse the operator extension methods (`Map`, `Filter`, `MergeMap`, ...) and `RxSharp.Extras` for the Puppeteer-oriented combinators (`Timeout`, `RetryAndRaceWithSignalAndTimer`, ...). +Start with [`Observable`](ReactiveExtensionsSharp.Observable-1.yml) and the static [`Observable`](ReactiveExtensionsSharp.Observable.yml) factory class for creation functions (`Of`, `From`, `Timer`, `Merge`, ...), then browse the operator extension methods (`Map`, `Filter`, `MergeMap`, ...) and `ReactiveExtensionsSharp.Extras` for the Puppeteer-oriented combinators (`Timeout`, `RetryAndRaceWithSignalAndTimer`, ...). diff --git a/docfx_project/docfx.json b/docfx_project/docfx.json index e7d8fbe..74c610e 100644 --- a/docfx_project/docfx.json +++ b/docfx_project/docfx.json @@ -4,9 +4,9 @@ "src": [ { "files": [ - "RxSharp.csproj" + "ReactiveExtensionsSharp.csproj" ], - "src": "../src/RxSharp" + "src": "../src/ReactiveExtensionsSharp" } ], "dest": "api", @@ -43,7 +43,7 @@ ], "postProcessors": [], "globalMetadata": { - "_appTitle": "RxSharp", + "_appTitle": "ReactiveExtensionsSharp", "_appFooter": "Made with love by Dario Kondratiuk" }, "markdownEngineName": "markdig", diff --git a/docfx_project/index.md b/docfx_project/index.md index 4d72ba3..b752321 100644 --- a/docfx_project/index.md +++ b/docfx_project/index.md @@ -1,4 +1,4 @@ -# RxSharp +# ReactiveExtensionsSharp A .NET port of [RxJS](https://rxjs.dev/) — same operators, same semantics, same names you already know, in idiomatic C#. diff --git a/handoff/blog-post-material.md b/handoff/blog-post-material.md index c912f98..6f15f3b 100644 --- a/handoff/blog-post-material.md +++ b/handoff/blog-post-material.md @@ -1,4 +1,4 @@ -# Blog post material: RxSharp +# Blog post material: ReactiveExtensionsSharp Raw facts and content for a blog post about this project. No voice/tone direction here on purpose — just what was built, why, and what's technically interesting about it. The writer should shape this into whatever the @@ -6,7 +6,7 @@ actual post needs. ## The one-sentence pitch -RxSharp is a .NET port of RxJS — not "another Rx library," a *faithful port of RxJS specifically*: same operator +ReactiveExtensionsSharp is a .NET port of RxJS — not "another Rx library," a *faithful port of RxJS specifically*: same operator names, same semantics, same edge-case behavior, verified test-for-test against RxJS's own upstream spec suite (tag `7.8.2`). If you know `source$.pipe(map(x => x * 2), filter(x => x > 0))`, you already know how to use it. @@ -33,7 +33,7 @@ Rx.NET for any of this — it hand-rolls the equivalent logic with `Cancellation loops, and manual `catch` clauses to disambiguate "timed out" from "cancelled" from "just retry this attempt." That code works, but it's bespoke, and every time upstream Puppeteer's JS reactive pipeline changes, someone has to re-derive the C# equivalent from scratch by reading rxjs semantics and re-implementing them imperatively. -RxSharp exists so that translation becomes mechanical: the same rxjs operator, same name, same behavior, already +ReactiveExtensionsSharp exists so that translation becomes mechanical: the same rxjs operator, same name, same behavior, already sitting there in C#. ### Concrete before/after: what this replaces @@ -88,7 +88,7 @@ private async Task RunWithRetryAsync( } ``` -The RxSharp equivalent, proven against a real launched Chrome: +The ReactiveExtensionsSharp equivalent, proven against a real launched Chrome: ```csharp await Observable.Defer(() => Observable.From(ClickOnceAsync())) diff --git a/handoff/puppeteer-sharp-integration.md b/handoff/puppeteer-sharp-integration.md index 05fc000..35f8752 100644 --- a/handoff/puppeteer-sharp-integration.md +++ b/handoff/puppeteer-sharp-integration.md @@ -1,18 +1,18 @@ -# Handoff: integrating RxSharp into puppeteer-sharp +# Handoff: integrating ReactiveExtensionsSharp into puppeteer-sharp This doc is written for whoever (human or agent) picks up the actual integration work: replacing -puppeteer-sharp's hand-rolled async/retry/cancellation plumbing with RxSharp, the way upstream Puppeteer (JS) +puppeteer-sharp's hand-rolled async/retry/cancellation plumbing with ReactiveExtensionsSharp, the way upstream Puppeteer (JS) uses rxjs for the same job. It assumes no prior context on this project beyond what's written here — read this top to bottom before touching code. -## What RxSharp is +## What ReactiveExtensionsSharp is - GitHub: [`hardkoded/ReactiveExtensions-Sharp`](https://github.com/hardkoded/ReactiveExtensions-Sharp) (directory on disk may still be named `rxjs-sharp`) -- NuGet: `ReactiveExtensionsSharp` (the plain `RxSharp` name was taken; C# namespace is still `RxSharp`) +- NuGet: `ReactiveExtensionsSharp` (the plain `ReactiveExtensionsSharp` name was taken; C# namespace is still `ReactiveExtensionsSharp`) - API docs: - A faithful, test-for-test port of [RxJS 7.8.2](https://github.com/ReactiveX/rxjs/tree/7.8.2) — not a redesign, - not "Rx.NET but renamed." If you know the RxJS operator you're replacing, the RxSharp equivalent has the same + not "Rx.NET but renamed." If you know the RxJS operator you're replacing, the ReactiveExtensionsSharp equivalent has the same name, same semantics, same edge-case behavior, verified against RxJS's own upstream spec tests. - 800+ tests, all green, `TreatWarningsAsErrors` build, live NuGet package (Trusted Publishing, OIDC-based, no stored API key) and a GitHub Pages docs site, both wired to fire on version tags. @@ -43,7 +43,7 @@ export { } from 'rxjs'; ``` -**39 of these 40 symbols have a direct RxSharp equivalent, same name (PascalCase), same behavior.** The one +**39 of these 40 symbols have a direct ReactiveExtensionsSharp equivalent, same name (PascalCase), same behavior.** The one exception is `pipe` — see "The one real idiom gap" below, it's intentional, not missing functionality. Puppeteer builds three real features on top of this list, all three now proven to work end-to-end against a @@ -58,7 +58,7 @@ real launched Chrome (see "Proof this actually works" below): ## The one real idiom gap: `pipe()` RxJS's `pipe()` is a hand-written, overloaded-up-to-9-arguments function: `source$.pipe(map(f), filter(g), -takeUntil(h$))`. RxSharp deliberately does **not** port that — see `CLAUDE.md`'s Core design section. The direct +takeUntil(h$))`. ReactiveExtensionsSharp deliberately does **not** port that — see `CLAUDE.md`'s Core design section. The direct replacement idiom is **extension-method chaining**: ```csharp @@ -76,7 +76,7 @@ Puppeteer's own code — none of them do anything with `pipe()` that chaining ca - **`FromEvent` is not a literal port.** RxJS's `fromEvent` duck-types across DOM `EventTarget`s, Node `EventEmitter`s, and a few other shapes. C# has no equivalent ambient duck-typing for "add/remove listener," so - RxSharp's `Observable.FromEvent` wraps a real **.NET event add/remove-handler pair** instead — the same idiom + ReactiveExtensionsSharp's `Observable.FromEvent` wraps a real **.NET event add/remove-handler pair** instead — the same idiom Rx.NET itself uses (`FromEvent`). Two overloads exist: - `FromEvent(Action> addHandler, Action> removeHandler)` — for `event EventHandler` members (covers most puppeteer-sharp events, e.g. `IPage.Console`). @@ -84,35 +84,35 @@ Puppeteer's own code — none of them do anything with `pipe()` that chaining ca `EventHandler` members (e.g. `IPage.Load`), where `conversion` adapts the delegate shape. Both are already proven against real puppeteer-sharp events — see the code below. - **`Zip`/`ForkJoin`/`CombineLatest` are same-type-array-only.** RxJS's versions accept heterogeneously-typed - tuples (`zip(a$: Observable, b$: Observable)`). RxSharp's take `params Observable[]` — every + tuples (`zip(a$: Observable, b$: Observable)`). ReactiveExtensionsSharp's take `params Observable[]` — every source must share one element type. Check whether Puppeteer's actual `combineLatest`/`zip`/`forkJoin` call sites need heterogeneous types before assuming this is a drop-in replacement for those specific calls; if they do, project each source to a common shape first (a small wrapper record/tuple) before combining, then `.Map()` the result apart afterward. - **No config-object overloads.** Where RxJS takes a single options object (e.g. `retry({count, delay, - resetOnSuccess})`), RxSharp exposes the same options as separate, named overloads instead (e.g. + resetOnSuccess})`), ReactiveExtensionsSharp exposes the same options as separate, named overloads instead (e.g. `Retry(count, delay, scheduler, resetOnSuccess)` and a second `Retry(delaySelector, count, resetOnSuccess)` overload for the notifier-based delay form). Same coverage, just no anonymous-object-literal ergonomics — not a gap, just a different (and, for a statically-typed language, more idiomatic) shape. - **`Unit`, not `never`.** Where RxJS types a stream as `Observable` (cancellation/timeout signals that - only ever error, never emit), RxSharp uses `Observable` (`RxSharp.Unit`, a real struct — C# has no bottom - type). `Observable.FromCancellationToken` and `RxSharp.Extras.Timeout` both return `Observable`. + only ever error, never emit), ReactiveExtensionsSharp uses `Observable` (`ReactiveExtensionsSharp.Unit`, a real struct — C# has no bottom + type). `Observable.FromCancellationToken` and `ReactiveExtensionsSharp.Extras.Timeout` both return `Observable`. -## `RxSharp.Extras` — the hand-built combinators that don't exist in rxjs itself +## `ReactiveExtensionsSharp.Extras` — the hand-built combinators that don't exist in rxjs itself Puppeteer's own rxjs usage isn't just the 40 wrapped symbols — it also builds a few combinators on top, inline, -at each call site. RxSharp extracted the common ones into `RxSharp.Extras` so they're reusable instead of +at each call site. ReactiveExtensionsSharp extracted the common ones into `ReactiveExtensionsSharp.Extras` so they're reusable instead of re-derived per call site: - **`Observable.FromCancellationToken(CancellationToken)`** — the `fromAbortSignal` analogue. Returns `Observable` that errors with `OperationCanceledException` when the token is cancelled, never emits otherwise. -- **`RxSharp.Extras.Timeout`** (`source.Timeout(TimeSpan, Func? causeFactory = null)`) — errors if +- **`ReactiveExtensionsSharp.Extras.Timeout`** (`source.Timeout(TimeSpan, Func? causeFactory = null)`) — errors if `source` doesn't emit within the given span. -- **`RxSharp.Extras.RetryAndRaceWithSignalAndTimer`** — the actual combinator behind `Locator` actions: +- **`ReactiveExtensionsSharp.Extras.RetryAndRaceWithSignalAndTimer`** — the actual combinator behind `Locator` actions: `pipe(retry({delay}), raceWith(fromAbortSignal(...), timeout(...)))` in one call. This is the single most important piece for the `Locator` integration — see below. -- **`RxSharp.Extras.FilterAsync`** — an async-predicate `Filter`, for cases where the filter condition itself +- **`ReactiveExtensionsSharp.Extras.FilterAsync`** — an async-predicate `Filter`, for cases where the filter condition itself needs an `await` (e.g. checking element visibility via a JS evaluation). ## Proof this actually works: the M3 playground @@ -126,11 +126,11 @@ in case that worktree isn't available wherever this integration actually happens All four tests below pass, end to end, launching a real browser via puppeteer-sharp's own `BrowserFetcher`: ```csharp -using RxSharp; -using RxSharp.Extras; +using ReactiveExtensionsSharp; +using ReactiveExtensionsSharp.Extras; // Mirrors Puppeteer's own Locator.click(): retry a click, racing against a timeout, built entirely -// from RxSharp primitives (Defer + RetryAndRaceWithSignalAndTimer) - no puppeteer-sharp Locator API +// from ReactiveExtensionsSharp primitives (Defer + RetryAndRaceWithSignalAndTimer) - no puppeteer-sharp Locator API // involved. The button is added to the page after a short delay, so the first few clicks fail with // "no node found" and only succeed once retry catches up. [Test] @@ -227,7 +227,7 @@ public async Task FromEventShouldWrapARealPlainEventHandlerPuppeteerSharpEvent() ## What this actually replaces — `Locator`'s current implementation Puppeteer-sharp's real `Locator` class (`lib/PuppeteerSharp/Locators/Locator.cs`, as of the version checked -while writing this doc) does **not** use RxSharp yet — it has its own hand-rolled retry loop, +while writing this doc) does **not** use ReactiveExtensionsSharp yet — it has its own hand-rolled retry loop, `RunWithRetryAsync`: ```csharp @@ -263,7 +263,7 @@ private async Task RunWithRetryAsync( This is **exactly** the shape `RetryAndRaceWithSignalAndTimer` exists to replace — a manual retry loop with a linked timeout/cancellation `CancellationTokenSource`, several catch clauses to disambiguate timeout vs. -cancellation vs. "just retry," and a delay between attempts. The M3 playground test above proves the RxSharp +cancellation vs. "just retry," and a delay between attempts. The M3 playground test above proves the ReactiveExtensionsSharp replacement handles the same two cases (retry-until-success, retry-until-real-timeout) correctly against a real page. The integration here is mechanical: wrap `operation` in `Observable.Defer(() => Observable.From(...))`, call `.RetryAndRaceWithSignalAndTimer(timeout, causeFactory, retryDelay, cancellationToken)`, and @@ -282,13 +282,13 @@ that's a product decision, not something this doc can settle. end-to-end above, and touches the least surrounding code. 3. Port test-first, same discipline this whole port was built with: find `Locator`'s existing xunit/nunit tests (whichever framework puppeteer-sharp uses — check the test project), make sure they still pass against the - RxSharp-based implementation before considering it done. Don't just eyeball it. + ReactiveExtensionsSharp-based implementation before considering it done. Don't just eyeball it. 4. Once `Locator` is solid, look at `waitForNetworkIdle` (the `mergeScan`+`distinctUntilChanged` in-flight-request tracker) and `ScreenRecorder` (the `bufferCount`+`concatMap` frame-throttling) — both operators already exist - in RxSharp and are already tested, so this is the same "swap the hand-rolled version for the RxSharp one, keep + in ReactiveExtensionsSharp and are already tested, so this is the same "swap the hand-rolled version for the ReactiveExtensionsSharp one, keep the tests green" motion, not new operator-porting work. 5. For anything not covered above: check the exact RxJS symbol against `CLAUDE.md`'s "Puppeteer-essential surface" section first — if it's already ported, use it directly; if it's one of the deliberate gaps (`pipe`, heterogeneous `zip`/`combineLatest`/`forkJoin`), see the sections above for the workaround; if it's something - genuinely missing, that's a real gap worth filing against the RxSharp repo rather than working around + genuinely missing, that's a real gap worth filing against the ReactiveExtensionsSharp repo rather than working around silently, since the port's whole premise is broad, faithful RxJS parity. diff --git a/src/RxSharp/AsyncBridge.cs b/src/ReactiveExtensionsSharp/AsyncBridge.cs similarity index 99% rename from src/RxSharp/AsyncBridge.cs rename to src/ReactiveExtensionsSharp/AsyncBridge.cs index eceb1c9..73571fd 100644 --- a/src/RxSharp/AsyncBridge.cs +++ b/src/ReactiveExtensionsSharp/AsyncBridge.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Bridges an to a . Mirrors rxjs's firstValueFrom/lastValueFrom. public static class AsyncBridge diff --git a/src/RxSharp/EmptyErrorException.cs b/src/ReactiveExtensionsSharp/EmptyErrorException.cs similarity index 95% rename from src/RxSharp/EmptyErrorException.cs rename to src/ReactiveExtensionsSharp/EmptyErrorException.cs index f8dcdd2..effc768 100644 --- a/src/RxSharp/EmptyErrorException.cs +++ b/src/ReactiveExtensionsSharp/EmptyErrorException.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Thrown by operators such as First when a source completes without emitting a value and no default was supplied. Mirrors rxjs's EmptyError. public sealed class EmptyErrorException : Exception diff --git a/src/RxSharp/Extras/AssumeNeverEmits.cs b/src/ReactiveExtensionsSharp/Extras/AssumeNeverEmits.cs similarity index 96% rename from src/RxSharp/Extras/AssumeNeverEmits.cs rename to src/ReactiveExtensionsSharp/Extras/AssumeNeverEmits.cs index e5de4f0..e3e6add 100644 --- a/src/RxSharp/Extras/AssumeNeverEmits.cs +++ b/src/ReactiveExtensionsSharp/Extras/AssumeNeverEmits.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Extension methods widening an error-only to another element type. public static partial class RxExtensions diff --git a/src/RxSharp/Extras/FilterAsync.cs b/src/ReactiveExtensionsSharp/Extras/FilterAsync.cs similarity index 94% rename from src/RxSharp/Extras/FilterAsync.cs rename to src/ReactiveExtensionsSharp/Extras/FilterAsync.cs index df46de6..5ce764e 100644 --- a/src/RxSharp/Extras/FilterAsync.cs +++ b/src/ReactiveExtensionsSharp/Extras/FilterAsync.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Extension methods providing an async-predicate flavor of Filter. public static partial class RxExtensions diff --git a/src/RxSharp/Extras/FromCancellationToken.cs b/src/ReactiveExtensionsSharp/Extras/FromCancellationToken.cs similarity index 97% rename from src/RxSharp/Extras/FromCancellationToken.cs rename to src/ReactiveExtensionsSharp/Extras/FromCancellationToken.cs index c058642..96db742 100644 --- a/src/RxSharp/Extras/FromCancellationToken.cs +++ b/src/ReactiveExtensionsSharp/Extras/FromCancellationToken.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Puppeteer-flavored combinators built on top of the core primitives — the C# analogues of the helpers Puppeteer itself layers on top of rxjs (see CLAUDE.md's "Puppeteer-essential surface"). public static partial class RxExtensions diff --git a/src/RxSharp/Extras/FromEventBuffered.cs b/src/ReactiveExtensionsSharp/Extras/FromEventBuffered.cs similarity index 97% rename from src/RxSharp/Extras/FromEventBuffered.cs rename to src/ReactiveExtensionsSharp/Extras/FromEventBuffered.cs index dc8a05b..c119fcd 100644 --- a/src/RxSharp/Extras/FromEventBuffered.cs +++ b/src/ReactiveExtensionsSharp/Extras/FromEventBuffered.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// /// A handle to an eagerly-attached, buffered .NET event source created by @@ -52,7 +52,7 @@ public static partial class RxExtensions /// /// /// Ordinary is cold: nothing is attached to the - /// underlying event until Subscribe is called, matching every other RxSharp source. This is + /// underlying event until Subscribe is called, matching every other ReactiveExtensionsSharp source. This is /// deliberately not that. It exists for the narrow case where a handler must be attached before /// synchronously checking some existing state that might already satisfy what the caller is waiting for /// (e.g. checking a collection for an already-matching item) without losing an event that fires in the real diff --git a/src/RxSharp/Extras/RaceWithSignalAndTimer.cs b/src/ReactiveExtensionsSharp/Extras/RaceWithSignalAndTimer.cs similarity index 97% rename from src/RxSharp/Extras/RaceWithSignalAndTimer.cs rename to src/ReactiveExtensionsSharp/Extras/RaceWithSignalAndTimer.cs index 6253f0f..19420a2 100644 --- a/src/RxSharp/Extras/RaceWithSignalAndTimer.cs +++ b/src/ReactiveExtensionsSharp/Extras/RaceWithSignalAndTimer.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Extension methods racing a single subscription against cancellation and a timeout. public static partial class RxExtensions diff --git a/src/RxSharp/Extras/RetryAndRaceWithSignalAndTimer.cs b/src/ReactiveExtensionsSharp/Extras/RetryAndRaceWithSignalAndTimer.cs similarity index 97% rename from src/RxSharp/Extras/RetryAndRaceWithSignalAndTimer.cs rename to src/ReactiveExtensionsSharp/Extras/RetryAndRaceWithSignalAndTimer.cs index 1cc2dd9..5b4aa49 100644 --- a/src/RxSharp/Extras/RetryAndRaceWithSignalAndTimer.cs +++ b/src/ReactiveExtensionsSharp/Extras/RetryAndRaceWithSignalAndTimer.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Extension methods composing retry, cancellation, and timeout into the single combinator Puppeteer's Locator actions rely on. public static partial class RxExtensions diff --git a/src/RxSharp/Extras/Timeout.cs b/src/ReactiveExtensionsSharp/Extras/Timeout.cs similarity index 95% rename from src/RxSharp/Extras/Timeout.cs rename to src/ReactiveExtensionsSharp/Extras/Timeout.cs index b692bd7..4898835 100644 --- a/src/RxSharp/Extras/Timeout.cs +++ b/src/ReactiveExtensionsSharp/Extras/Timeout.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Extras; +namespace ReactiveExtensionsSharp.Extras; /// Extension methods providing a standalone, -throwing timer observable. public static partial class RxExtensions diff --git a/src/RxSharp/GroupedObservable.cs b/src/ReactiveExtensionsSharp/GroupedObservable.cs similarity index 93% rename from src/RxSharp/GroupedObservable.cs rename to src/ReactiveExtensionsSharp/GroupedObservable.cs index 920a851..46df942 100644 --- a/src/RxSharp/GroupedObservable.cs +++ b/src/ReactiveExtensionsSharp/GroupedObservable.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Concrete used by GroupBy. Backed by a diff --git a/src/RxSharp/IGroupedObservable.cs b/src/ReactiveExtensionsSharp/IGroupedObservable.cs similarity index 97% rename from src/RxSharp/IGroupedObservable.cs rename to src/ReactiveExtensionsSharp/IGroupedObservable.cs index 3301e9b..a5a64bd 100644 --- a/src/RxSharp/IGroupedObservable.cs +++ b/src/ReactiveExtensionsSharp/IGroupedObservable.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// An -shaped stream of values that all share a common . Mirrors diff --git a/src/RxSharp/IScheduler.cs b/src/ReactiveExtensionsSharp/IScheduler.cs similarity index 96% rename from src/RxSharp/IScheduler.cs rename to src/ReactiveExtensionsSharp/IScheduler.cs index c0842db..831f031 100644 --- a/src/RxSharp/IScheduler.cs +++ b/src/ReactiveExtensionsSharp/IScheduler.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Schedules work after a delay. Mirrors rxjs's SchedulerLike. A minimal seam for now — see CLAUDE.md for the plan to grow this into a full scheduler hierarchy with a virtual-time implementation. public interface IScheduler diff --git a/src/RxSharp/NotFoundErrorException.cs b/src/ReactiveExtensionsSharp/NotFoundErrorException.cs similarity index 95% rename from src/RxSharp/NotFoundErrorException.cs rename to src/ReactiveExtensionsSharp/NotFoundErrorException.cs index 75b7fa8..81a8bec 100644 --- a/src/RxSharp/NotFoundErrorException.cs +++ b/src/ReactiveExtensionsSharp/NotFoundErrorException.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Thrown by Single when the source emits one or more values but none of them satisfy the supplied diff --git a/src/RxSharp/Notification.cs b/src/ReactiveExtensionsSharp/Notification.cs similarity index 91% rename from src/RxSharp/Notification.cs rename to src/ReactiveExtensionsSharp/Notification.cs index 84de231..445795b 100644 --- a/src/RxSharp/Notification.cs +++ b/src/ReactiveExtensionsSharp/Notification.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Identifies which kind of notification a represents. public enum NotificationKind @@ -21,11 +21,11 @@ public enum NotificationKind /// (which converts them back). /// /// -/// This lives in the main RxSharp namespace, not RxSharp.Testing, since materialize/dematerialize -/// are core operators rather than test-only utilities. RxSharp.Testing has a superficially similar type, -/// , but that type also carries a +/// This lives in the main ReactiveExtensionsSharp namespace, not ReactiveExtensionsSharp.Testing, since materialize/dematerialize +/// are core operators rather than test-only utilities. ReactiveExtensionsSharp.Testing has a superficially similar type, +/// , but that type also carries a /// clock timestamp that has no meaning here, and core types should not depend on the testing namespace — so -/// this is a separate, deliberately simpler type rather than a reuse of . +/// this is a separate, deliberately simpler type rather than a reuse of . /// /// The type of value carried by a notification. public readonly struct Notification : IEquatable> diff --git a/src/RxSharp/Observable.Creation.cs b/src/ReactiveExtensionsSharp/Observable.Creation.cs similarity index 99% rename from src/RxSharp/Observable.Creation.cs rename to src/ReactiveExtensionsSharp/Observable.Creation.cs index 944e74a..08285bd 100644 --- a/src/RxSharp/Observable.Creation.cs +++ b/src/ReactiveExtensionsSharp/Observable.Creation.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Creation functions for . Mirrors rxjs's observable/ creation functions. public static class Observable @@ -416,7 +416,7 @@ void SubscribeNext() /// same child subscriber — would also (incorrectly) advance to the next source on a plain external /// unsubscribe, not just on the current source's own completion or error. Here, moving to the next source is /// triggered directly from inside the current source's onError/onComplete callbacks only - /// (matching the pattern uses for its own per-attempt + /// (matching the pattern uses for its own per-attempt /// resubscription), so an external unsubscribe correctly stops the whole chain instead of skipping ahead. /// /// The type of the emitted values. @@ -774,7 +774,7 @@ public static Func> BindCallback(Action func) /// /// Deliberate deviations from rxjs's literal bindCallback: /// - /// No scheduler parameter: rxjs composes an optional scheduler via its own subscribeOn/observeOn operators, which RxSharp does not have yet. The wrapped function is always invoked synchronously, on the subscribing thread, at first-subscribe time. + /// No scheduler parameter: rxjs composes an optional scheduler via its own subscribeOn/observeOn operators, which ReactiveExtensionsSharp does not have yet. The wrapped function is always invoked synchronously, on the subscribing thread, at first-subscribe time. /// No resultSelector parameter: since the returned function already produces a full , a caller gets the same effect (and more idiomatically) via .Map(selector) on the result. /// Only a single result value is supported (rxjs packs multiple callback arguments into an array). C# delegates aren't variadic; a callback-style API with several logically-related result values should bundle them into a tuple or record before calling back. /// No JS-style dynamic this rebinding (rxjs's .apply/.call tests): the wrapped delegate already captures whatever state/closure the caller bound it to. diff --git a/src/RxSharp/Observable.cs b/src/ReactiveExtensionsSharp/Observable.cs similarity index 99% rename from src/RxSharp/Observable.cs rename to src/ReactiveExtensionsSharp/Observable.cs index 77b5576..9833a3b 100644 --- a/src/RxSharp/Observable.cs +++ b/src/ReactiveExtensionsSharp/Observable.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// A push-based sequence of values. Mirrors rxjs's Observable. /// The type of the values this observable emits. diff --git a/src/RxSharp/OperatorFunction.cs b/src/ReactiveExtensionsSharp/OperatorFunction.cs similarity index 99% rename from src/RxSharp/OperatorFunction.cs rename to src/ReactiveExtensionsSharp/OperatorFunction.cs index 8388a57..bae3df7 100644 --- a/src/RxSharp/OperatorFunction.cs +++ b/src/ReactiveExtensionsSharp/OperatorFunction.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// A function that transforms an into an , e.g. the shape of a bound operator ready to apply via . /// The element type of the source observable. diff --git a/src/RxSharp/Operators/Audit.cs b/src/ReactiveExtensionsSharp/Operators/Audit.cs similarity index 99% rename from src/RxSharp/Operators/Audit.cs rename to src/ReactiveExtensionsSharp/Operators/Audit.cs index 4df8147..3779a8f 100644 --- a/src/RxSharp/Operators/Audit.cs +++ b/src/ReactiveExtensionsSharp/Operators/Audit.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The audit/auditTime operators. public static class AuditOperator diff --git a/src/RxSharp/Operators/Buffer.cs b/src/ReactiveExtensionsSharp/Operators/Buffer.cs similarity index 98% rename from src/RxSharp/Operators/Buffer.cs rename to src/ReactiveExtensionsSharp/Operators/Buffer.cs index 094c3b4..14959af 100644 --- a/src/RxSharp/Operators/Buffer.cs +++ b/src/ReactiveExtensionsSharp/Operators/Buffer.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The buffer operator. public static class BufferOperator diff --git a/src/RxSharp/Operators/BufferCount.cs b/src/ReactiveExtensionsSharp/Operators/BufferCount.cs similarity index 98% rename from src/RxSharp/Operators/BufferCount.cs rename to src/ReactiveExtensionsSharp/Operators/BufferCount.cs index ac0c5ea..695ebfc 100644 --- a/src/RxSharp/Operators/BufferCount.cs +++ b/src/ReactiveExtensionsSharp/Operators/BufferCount.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the BufferCount operator. Mirrors rxjs's bufferCount. public static class BufferCountOperator diff --git a/src/RxSharp/Operators/BufferTime.cs b/src/ReactiveExtensionsSharp/Operators/BufferTime.cs similarity index 99% rename from src/RxSharp/Operators/BufferTime.cs rename to src/ReactiveExtensionsSharp/Operators/BufferTime.cs index ee2c109..2c8a77e 100644 --- a/src/RxSharp/Operators/BufferTime.cs +++ b/src/ReactiveExtensionsSharp/Operators/BufferTime.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The bufferTime operator. public static class BufferTimeOperator diff --git a/src/RxSharp/Operators/BufferWhen.cs b/src/ReactiveExtensionsSharp/Operators/BufferWhen.cs similarity index 98% rename from src/RxSharp/Operators/BufferWhen.cs rename to src/ReactiveExtensionsSharp/Operators/BufferWhen.cs index 06ccceb..5b8718d 100644 --- a/src/RxSharp/Operators/BufferWhen.cs +++ b/src/ReactiveExtensionsSharp/Operators/BufferWhen.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The bufferWhen operator. public static class BufferWhenOperator diff --git a/src/RxSharp/Operators/CatchError.cs b/src/ReactiveExtensionsSharp/Operators/CatchError.cs similarity index 98% rename from src/RxSharp/Operators/CatchError.cs rename to src/ReactiveExtensionsSharp/Operators/CatchError.cs index cb3b628..9379a83 100644 --- a/src/RxSharp/Operators/CatchError.cs +++ b/src/ReactiveExtensionsSharp/Operators/CatchError.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the CatchError operator. Mirrors rxjs's catchError. public static class CatchErrorOperator diff --git a/src/RxSharp/Operators/CombineLatestAll.cs b/src/ReactiveExtensionsSharp/Operators/CombineLatestAll.cs similarity index 76% rename from src/RxSharp/Operators/CombineLatestAll.cs rename to src/ReactiveExtensionsSharp/Operators/CombineLatestAll.cs index 415ae6b..b0d282f 100644 --- a/src/RxSharp/Operators/CombineLatestAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/CombineLatestAll.cs @@ -1,17 +1,17 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the combineLatestAll operator. public static class CombineLatestAllOperator { /// /// Collects every inner observable produced by and, once - /// completes, combines all of them with : every time any + /// completes, combines all of them with : every time any /// collected inner observable emits (once every one of them has emitted at least once), the output emits a /// list of the latest values from each. Ported from rxjs's joinAllInternals applied to /// combineLatest: source.ToArray().MergeMap(sources => CombineLatest(sources)). /// /// - /// Same-type-only, like itself: this does not port rxjs's + /// Same-type-only, like itself: this does not port rxjs's /// optional project parameter (a heterogeneous-arity result selector), which has no clean C# equivalent /// for the same reason Zip/ForkJoin/CombineLatest stayed same-type-array-only. Apply /// .Map(...) to the result instead if a projection is needed. @@ -20,5 +20,5 @@ public static class CombineLatestAllOperator /// The higher-order source sequence. /// An observable that emits a list of the latest values from every collected inner observable, updated as they emit. public static Observable> CombineLatestAll(this Observable> source) - => source.ToArray().MergeMap(sources => RxSharp.Observable.CombineLatest(sources.ToArray())); + => source.ToArray().MergeMap(sources => ReactiveExtensionsSharp.Observable.CombineLatest(sources.ToArray())); } diff --git a/src/RxSharp/Operators/CombineLatestWith.cs b/src/ReactiveExtensionsSharp/Operators/CombineLatestWith.cs similarity index 83% rename from src/RxSharp/Operators/CombineLatestWith.cs rename to src/ReactiveExtensionsSharp/Operators/CombineLatestWith.cs index 45a72d5..600b5db 100644 --- a/src/RxSharp/Operators/CombineLatestWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/CombineLatestWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the combineLatestWith operator. public static class CombineLatestWithOperator @@ -6,12 +6,12 @@ public static class CombineLatestWithOperator /// /// Subscribes to and every one of , emitting a list /// of the latest values from each once every one of them has emitted at least once, and again every time any - /// of them emits thereafter. Pipeable-operator sugar over + /// of them emits thereafter. Pipeable-operator sugar over /// with prepended: source.CombineLatestWith(a, b) is the same as /// Observable.CombineLatest(source, a, b). /// /// - /// Same-type-only, like itself, rather than rxjs's + /// Same-type-only, like itself, rather than rxjs's /// heterogeneously-typed tuple result. /// /// The type of values shared by and . @@ -19,7 +19,7 @@ public static class CombineLatestWithOperator /// The other sequences to combine with . /// An observable that emits a list of the latest values from and every one of . public static Observable> CombineLatestWith(this Observable source, params Observable[] otherSources) - => RxSharp.Observable.CombineLatest(Prepend(source, otherSources)); + => ReactiveExtensionsSharp.Observable.CombineLatest(Prepend(source, otherSources)); private static Observable[] Prepend(Observable source, Observable[] otherSources) { diff --git a/src/RxSharp/Operators/ConcatAll.cs b/src/ReactiveExtensionsSharp/Operators/ConcatAll.cs similarity index 95% rename from src/RxSharp/Operators/ConcatAll.cs rename to src/ReactiveExtensionsSharp/Operators/ConcatAll.cs index d5495d7..5dd07f2 100644 --- a/src/RxSharp/Operators/ConcatAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/ConcatAll.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the concatAll operator. public static class ConcatAllOperator diff --git a/src/RxSharp/Operators/ConcatMap.cs b/src/ReactiveExtensionsSharp/Operators/ConcatMap.cs similarity index 99% rename from src/RxSharp/Operators/ConcatMap.cs rename to src/ReactiveExtensionsSharp/Operators/ConcatMap.cs index 48d4d5a..f557473 100644 --- a/src/RxSharp/Operators/ConcatMap.cs +++ b/src/ReactiveExtensionsSharp/Operators/ConcatMap.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the ConcatMap operator. Mirrors rxjs's concatMap. public static class ConcatMapOperator diff --git a/src/RxSharp/Operators/ConcatMapTo.cs b/src/ReactiveExtensionsSharp/Operators/ConcatMapTo.cs similarity index 97% rename from src/RxSharp/Operators/ConcatMapTo.cs rename to src/ReactiveExtensionsSharp/Operators/ConcatMapTo.cs index 93b271f..cc07ba4 100644 --- a/src/RxSharp/Operators/ConcatMapTo.cs +++ b/src/ReactiveExtensionsSharp/Operators/ConcatMapTo.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the concatMapTo operator. public static class ConcatMapToOperator diff --git a/src/RxSharp/Operators/ConcatWith.cs b/src/ReactiveExtensionsSharp/Operators/ConcatWith.cs similarity index 85% rename from src/RxSharp/Operators/ConcatWith.cs rename to src/ReactiveExtensionsSharp/Operators/ConcatWith.cs index 353afc5..02b99eb 100644 --- a/src/RxSharp/Operators/ConcatWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/ConcatWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the concatWith operator. public static class ConcatWithOperator @@ -6,7 +6,7 @@ public static class ConcatWithOperator /// /// Emits all values from , then, once it completes, subscribes to each of /// in turn, one at a time. Pipeable-operator sugar over - /// with prepended: + /// with prepended: /// source.ConcatWith(a, b) is the same as Observable.Concat(source, a, b). /// /// The type of values shared by and . @@ -14,7 +14,7 @@ public static class ConcatWithOperator /// The other sequences to subscribe to sequentially, in order, after completes. /// An observable that emits 's values followed by each of 's, in order. public static Observable ConcatWith(this Observable source, params Observable[] otherSources) - => RxSharp.Observable.Concat(Prepend(source, otherSources)); + => ReactiveExtensionsSharp.Observable.Concat(Prepend(source, otherSources)); private static Observable[] Prepend(Observable source, Observable[] otherSources) { diff --git a/src/RxSharp/Operators/Count.cs b/src/ReactiveExtensionsSharp/Operators/Count.cs similarity index 98% rename from src/RxSharp/Operators/Count.cs rename to src/ReactiveExtensionsSharp/Operators/Count.cs index 9e0230d..8f1ae05 100644 --- a/src/RxSharp/Operators/Count.cs +++ b/src/ReactiveExtensionsSharp/Operators/Count.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Count operator. Mirrors rxjs's count. public static class CountOperator diff --git a/src/RxSharp/Operators/Debounce.cs b/src/ReactiveExtensionsSharp/Operators/Debounce.cs similarity index 98% rename from src/RxSharp/Operators/Debounce.cs rename to src/ReactiveExtensionsSharp/Operators/Debounce.cs index c338433..30f6158 100644 --- a/src/RxSharp/Operators/Debounce.cs +++ b/src/ReactiveExtensionsSharp/Operators/Debounce.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The debounce operator. public static class DebounceOperator diff --git a/src/RxSharp/Operators/DebounceTime.cs b/src/ReactiveExtensionsSharp/Operators/DebounceTime.cs similarity index 98% rename from src/RxSharp/Operators/DebounceTime.cs rename to src/ReactiveExtensionsSharp/Operators/DebounceTime.cs index 0607a3b..a4d06fa 100644 --- a/src/RxSharp/Operators/DebounceTime.cs +++ b/src/ReactiveExtensionsSharp/Operators/DebounceTime.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the DebounceTime operator. Mirrors rxjs's debounceTime. public static class DebounceTimeOperator diff --git a/src/RxSharp/Operators/DefaultIfEmpty.cs b/src/ReactiveExtensionsSharp/Operators/DefaultIfEmpty.cs similarity index 97% rename from src/RxSharp/Operators/DefaultIfEmpty.cs rename to src/ReactiveExtensionsSharp/Operators/DefaultIfEmpty.cs index 5f4ea28..eebe048 100644 --- a/src/RxSharp/Operators/DefaultIfEmpty.cs +++ b/src/ReactiveExtensionsSharp/Operators/DefaultIfEmpty.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the DefaultIfEmpty operator. Mirrors rxjs's defaultIfEmpty. public static class DefaultIfEmptyOperator diff --git a/src/RxSharp/Operators/Delay.cs b/src/ReactiveExtensionsSharp/Operators/Delay.cs similarity index 98% rename from src/RxSharp/Operators/Delay.cs rename to src/ReactiveExtensionsSharp/Operators/Delay.cs index 1c8d756..bd6f63b 100644 --- a/src/RxSharp/Operators/Delay.cs +++ b/src/ReactiveExtensionsSharp/Operators/Delay.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Delay operator. Mirrors rxjs's delay. public static class DelayOperator diff --git a/src/RxSharp/Operators/DelayWhen.cs b/src/ReactiveExtensionsSharp/Operators/DelayWhen.cs similarity index 98% rename from src/RxSharp/Operators/DelayWhen.cs rename to src/ReactiveExtensionsSharp/Operators/DelayWhen.cs index ec5a247..017ef39 100644 --- a/src/RxSharp/Operators/DelayWhen.cs +++ b/src/ReactiveExtensionsSharp/Operators/DelayWhen.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the DelayWhen operator. Mirrors rxjs's delayWhen. public static class DelayWhenOperator diff --git a/src/RxSharp/Operators/Distinct.cs b/src/ReactiveExtensionsSharp/Operators/Distinct.cs similarity index 99% rename from src/RxSharp/Operators/Distinct.cs rename to src/ReactiveExtensionsSharp/Operators/Distinct.cs index c61a019..3a6c7be 100644 --- a/src/RxSharp/Operators/Distinct.cs +++ b/src/ReactiveExtensionsSharp/Operators/Distinct.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Distinct operator. Mirrors rxjs's distinct. public static class DistinctOperator diff --git a/src/RxSharp/Operators/DistinctUntilChanged.cs b/src/ReactiveExtensionsSharp/Operators/DistinctUntilChanged.cs similarity index 99% rename from src/RxSharp/Operators/DistinctUntilChanged.cs rename to src/ReactiveExtensionsSharp/Operators/DistinctUntilChanged.cs index 8283ac3..b87e115 100644 --- a/src/RxSharp/Operators/DistinctUntilChanged.cs +++ b/src/ReactiveExtensionsSharp/Operators/DistinctUntilChanged.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the DistinctUntilChanged operator. Mirrors rxjs's distinctUntilChanged. public static class DistinctUntilChangedOperator diff --git a/src/RxSharp/Operators/ElementAt.cs b/src/ReactiveExtensionsSharp/Operators/ElementAt.cs similarity index 98% rename from src/RxSharp/Operators/ElementAt.cs rename to src/ReactiveExtensionsSharp/Operators/ElementAt.cs index 80203af..3195a79 100644 --- a/src/RxSharp/Operators/ElementAt.cs +++ b/src/ReactiveExtensionsSharp/Operators/ElementAt.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the ElementAt operator. Mirrors rxjs's elementAt. public static class ElementAtOperator diff --git a/src/RxSharp/Operators/EndWith.cs b/src/ReactiveExtensionsSharp/Operators/EndWith.cs similarity index 97% rename from src/RxSharp/Operators/EndWith.cs rename to src/ReactiveExtensionsSharp/Operators/EndWith.cs index 2467d07..e7b7422 100644 --- a/src/RxSharp/Operators/EndWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/EndWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the endWith operator. /// diff --git a/src/RxSharp/Operators/Every.cs b/src/ReactiveExtensionsSharp/Operators/Every.cs similarity index 98% rename from src/RxSharp/Operators/Every.cs rename to src/ReactiveExtensionsSharp/Operators/Every.cs index 181e65f..ced90f8 100644 --- a/src/RxSharp/Operators/Every.cs +++ b/src/ReactiveExtensionsSharp/Operators/Every.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Every operator. Mirrors rxjs's every. public static class EveryOperator diff --git a/src/RxSharp/Operators/ExhaustAll.cs b/src/ReactiveExtensionsSharp/Operators/ExhaustAll.cs similarity index 95% rename from src/RxSharp/Operators/ExhaustAll.cs rename to src/ReactiveExtensionsSharp/Operators/ExhaustAll.cs index 5445758..d6f718d 100644 --- a/src/RxSharp/Operators/ExhaustAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/ExhaustAll.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the exhaustAll operator. public static class ExhaustAllOperator diff --git a/src/RxSharp/Operators/ExhaustMap.cs b/src/ReactiveExtensionsSharp/Operators/ExhaustMap.cs similarity index 99% rename from src/RxSharp/Operators/ExhaustMap.cs rename to src/ReactiveExtensionsSharp/Operators/ExhaustMap.cs index 84e126a..781988f 100644 --- a/src/RxSharp/Operators/ExhaustMap.cs +++ b/src/ReactiveExtensionsSharp/Operators/ExhaustMap.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the exhaustMap operator. public static class ExhaustMapOperator diff --git a/src/RxSharp/Operators/Expand.cs b/src/ReactiveExtensionsSharp/Operators/Expand.cs similarity index 99% rename from src/RxSharp/Operators/Expand.cs rename to src/ReactiveExtensionsSharp/Operators/Expand.cs index 434c173..87d7c7a 100644 --- a/src/RxSharp/Operators/Expand.cs +++ b/src/ReactiveExtensionsSharp/Operators/Expand.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// /// Extension methods implementing the expand operator. diff --git a/src/RxSharp/Operators/Filter.cs b/src/ReactiveExtensionsSharp/Operators/Filter.cs similarity index 98% rename from src/RxSharp/Operators/Filter.cs rename to src/ReactiveExtensionsSharp/Operators/Filter.cs index e3b1096..01d445f 100644 --- a/src/RxSharp/Operators/Filter.cs +++ b/src/ReactiveExtensionsSharp/Operators/Filter.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Filter operator. Mirrors rxjs's filter. public static class FilterOperator diff --git a/src/RxSharp/Operators/Finalize.cs b/src/ReactiveExtensionsSharp/Operators/Finalize.cs similarity index 98% rename from src/RxSharp/Operators/Finalize.cs rename to src/ReactiveExtensionsSharp/Operators/Finalize.cs index 57721b2..f40567f 100644 --- a/src/RxSharp/Operators/Finalize.cs +++ b/src/ReactiveExtensionsSharp/Operators/Finalize.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the finalize operator. public static class FinalizeOperator diff --git a/src/RxSharp/Operators/Find.cs b/src/ReactiveExtensionsSharp/Operators/Find.cs similarity index 99% rename from src/RxSharp/Operators/Find.cs rename to src/ReactiveExtensionsSharp/Operators/Find.cs index e850454..95418e5 100644 --- a/src/RxSharp/Operators/Find.cs +++ b/src/ReactiveExtensionsSharp/Operators/Find.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Find operator. Mirrors rxjs's find. public static class FindOperator diff --git a/src/RxSharp/Operators/FindIndex.cs b/src/ReactiveExtensionsSharp/Operators/FindIndex.cs similarity index 98% rename from src/RxSharp/Operators/FindIndex.cs rename to src/ReactiveExtensionsSharp/Operators/FindIndex.cs index 1bb9a46..7e2b27f 100644 --- a/src/RxSharp/Operators/FindIndex.cs +++ b/src/ReactiveExtensionsSharp/Operators/FindIndex.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the FindIndex operator. Mirrors rxjs's findIndex. public static class FindIndexOperator diff --git a/src/RxSharp/Operators/First.cs b/src/ReactiveExtensionsSharp/Operators/First.cs similarity index 99% rename from src/RxSharp/Operators/First.cs rename to src/ReactiveExtensionsSharp/Operators/First.cs index ba3c5fa..ffd9b44 100644 --- a/src/RxSharp/Operators/First.cs +++ b/src/ReactiveExtensionsSharp/Operators/First.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the First operator. Mirrors rxjs's first. public static class FirstOperator diff --git a/src/RxSharp/Operators/GroupBy.cs b/src/ReactiveExtensionsSharp/Operators/GroupBy.cs similarity index 99% rename from src/RxSharp/Operators/GroupBy.cs rename to src/ReactiveExtensionsSharp/Operators/GroupBy.cs index f0cb463..53271be 100644 --- a/src/RxSharp/Operators/GroupBy.cs +++ b/src/ReactiveExtensionsSharp/Operators/GroupBy.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The groupBy operator. See the main overload below for full behavior. public static class GroupByOperator diff --git a/src/RxSharp/Operators/IgnoreElements.cs b/src/ReactiveExtensionsSharp/Operators/IgnoreElements.cs similarity index 95% rename from src/RxSharp/Operators/IgnoreElements.cs rename to src/ReactiveExtensionsSharp/Operators/IgnoreElements.cs index da0344d..9daadbe 100644 --- a/src/RxSharp/Operators/IgnoreElements.cs +++ b/src/ReactiveExtensionsSharp/Operators/IgnoreElements.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the IgnoreElements operator. Mirrors rxjs's ignoreElements. public static class IgnoreElementsOperator diff --git a/src/RxSharp/Operators/IsEmpty.cs b/src/ReactiveExtensionsSharp/Operators/IsEmpty.cs similarity index 97% rename from src/RxSharp/Operators/IsEmpty.cs rename to src/ReactiveExtensionsSharp/Operators/IsEmpty.cs index 190cb09..c6f7916 100644 --- a/src/RxSharp/Operators/IsEmpty.cs +++ b/src/ReactiveExtensionsSharp/Operators/IsEmpty.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the IsEmpty operator. Mirrors rxjs's isEmpty. public static class IsEmptyOperator diff --git a/src/RxSharp/Operators/Last.cs b/src/ReactiveExtensionsSharp/Operators/Last.cs similarity index 99% rename from src/RxSharp/Operators/Last.cs rename to src/ReactiveExtensionsSharp/Operators/Last.cs index e48832b..e764900 100644 --- a/src/RxSharp/Operators/Last.cs +++ b/src/ReactiveExtensionsSharp/Operators/Last.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Last operator. Mirrors rxjs's last. public static class LastOperator diff --git a/src/RxSharp/Operators/Map.cs b/src/ReactiveExtensionsSharp/Operators/Map.cs similarity index 98% rename from src/RxSharp/Operators/Map.cs rename to src/ReactiveExtensionsSharp/Operators/Map.cs index b500fc6..ce821a2 100644 --- a/src/RxSharp/Operators/Map.cs +++ b/src/ReactiveExtensionsSharp/Operators/Map.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the map operator. public static class MapOperator diff --git a/src/RxSharp/Operators/MapTo.cs b/src/ReactiveExtensionsSharp/Operators/MapTo.cs similarity index 96% rename from src/RxSharp/Operators/MapTo.cs rename to src/ReactiveExtensionsSharp/Operators/MapTo.cs index cca5758..bc59bb7 100644 --- a/src/RxSharp/Operators/MapTo.cs +++ b/src/ReactiveExtensionsSharp/Operators/MapTo.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the mapTo operator. public static class MapToOperator diff --git a/src/RxSharp/Operators/Materialize.cs b/src/ReactiveExtensionsSharp/Operators/Materialize.cs similarity index 98% rename from src/RxSharp/Operators/Materialize.cs rename to src/ReactiveExtensionsSharp/Operators/Materialize.cs index e577a0c..3d646a6 100644 --- a/src/RxSharp/Operators/Materialize.cs +++ b/src/ReactiveExtensionsSharp/Operators/Materialize.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the materialize and dematerialize operators. public static class MaterializeOperator diff --git a/src/RxSharp/Operators/Max.cs b/src/ReactiveExtensionsSharp/Operators/Max.cs similarity index 98% rename from src/RxSharp/Operators/Max.cs rename to src/ReactiveExtensionsSharp/Operators/Max.cs index 06b532f..e0dab9c 100644 --- a/src/RxSharp/Operators/Max.cs +++ b/src/ReactiveExtensionsSharp/Operators/Max.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the max operator. /// diff --git a/src/RxSharp/Operators/MergeAll.cs b/src/ReactiveExtensionsSharp/Operators/MergeAll.cs similarity index 95% rename from src/RxSharp/Operators/MergeAll.cs rename to src/ReactiveExtensionsSharp/Operators/MergeAll.cs index 5483244..66f7b9c 100644 --- a/src/RxSharp/Operators/MergeAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/MergeAll.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the mergeAll operator. public static class MergeAllOperator diff --git a/src/RxSharp/Operators/MergeMap.cs b/src/ReactiveExtensionsSharp/Operators/MergeMap.cs similarity index 99% rename from src/RxSharp/Operators/MergeMap.cs rename to src/ReactiveExtensionsSharp/Operators/MergeMap.cs index 5593533..f04e53e 100644 --- a/src/RxSharp/Operators/MergeMap.cs +++ b/src/ReactiveExtensionsSharp/Operators/MergeMap.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// /// Extension methods implementing the mergeMap operator. diff --git a/src/RxSharp/Operators/MergeMapTo.cs b/src/ReactiveExtensionsSharp/Operators/MergeMapTo.cs similarity index 97% rename from src/RxSharp/Operators/MergeMapTo.cs rename to src/ReactiveExtensionsSharp/Operators/MergeMapTo.cs index c325bee..6d62ae6 100644 --- a/src/RxSharp/Operators/MergeMapTo.cs +++ b/src/ReactiveExtensionsSharp/Operators/MergeMapTo.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the mergeMapTo operator. public static class MergeMapToOperator diff --git a/src/RxSharp/Operators/MergeScan.cs b/src/ReactiveExtensionsSharp/Operators/MergeScan.cs similarity index 99% rename from src/RxSharp/Operators/MergeScan.cs rename to src/ReactiveExtensionsSharp/Operators/MergeScan.cs index c51ed42..381e0c1 100644 --- a/src/RxSharp/Operators/MergeScan.cs +++ b/src/ReactiveExtensionsSharp/Operators/MergeScan.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the mergeScan operator. public static class MergeScanOperator diff --git a/src/RxSharp/Operators/MergeWith.cs b/src/ReactiveExtensionsSharp/Operators/MergeWith.cs similarity index 85% rename from src/RxSharp/Operators/MergeWith.cs rename to src/ReactiveExtensionsSharp/Operators/MergeWith.cs index 810d930..55e0854 100644 --- a/src/RxSharp/Operators/MergeWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/MergeWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the mergeWith operator. public static class MergeWithOperator @@ -6,7 +6,7 @@ public static class MergeWithOperator /// /// Subscribes to and every one of at the same /// time, emitting every value from every one of them as it arrives. Pipeable-operator sugar over - /// with prepended: + /// with prepended: /// source.MergeWith(a, b) is the same as Observable.Merge(source, a, b). /// /// The type of values shared by and . @@ -14,7 +14,7 @@ public static class MergeWithOperator /// The other sequences to merge with . /// An observable that emits the interleaved values of and every one of . public static Observable MergeWith(this Observable source, params Observable[] otherSources) - => RxSharp.Observable.Merge(Prepend(source, otherSources)); + => ReactiveExtensionsSharp.Observable.Merge(Prepend(source, otherSources)); private static Observable[] Prepend(Observable source, Observable[] otherSources) { diff --git a/src/RxSharp/Operators/Min.cs b/src/ReactiveExtensionsSharp/Operators/Min.cs similarity index 98% rename from src/RxSharp/Operators/Min.cs rename to src/ReactiveExtensionsSharp/Operators/Min.cs index 410ebc7..9defa05 100644 --- a/src/RxSharp/Operators/Min.cs +++ b/src/ReactiveExtensionsSharp/Operators/Min.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the min operator. /// diff --git a/src/RxSharp/Operators/OnErrorResumeNext.cs b/src/ReactiveExtensionsSharp/Operators/OnErrorResumeNext.cs similarity index 86% rename from src/RxSharp/Operators/OnErrorResumeNext.cs rename to src/ReactiveExtensionsSharp/Operators/OnErrorResumeNext.cs index 20066bc..339003f 100644 --- a/src/RxSharp/Operators/OnErrorResumeNext.cs +++ b/src/ReactiveExtensionsSharp/Operators/OnErrorResumeNext.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the pipeable-operator form of onErrorResumeNext. public static class OnErrorResumeNextOperator @@ -8,7 +8,7 @@ public static class OnErrorResumeNextOperator /// to the first of and continues the same way through the rest, in order, /// regardless of whether each one completes or errors. The output only completes once every source has been /// exhausted, and never itself errors. Pipeable-operator sugar over - /// with prepended: + /// with prepended: /// source.OnErrorResumeNext(a, b) is the same as Observable.OnErrorResumeNext(source, a, b). /// /// The type of values shared by and . @@ -16,7 +16,7 @@ public static class OnErrorResumeNextOperator /// The other sequences to subscribe to sequentially, in order, once ends (whether by completion or error). /// An observable that emits every source's values in sequence, moving past errors instead of forwarding them, completing once every source has ended. public static Observable OnErrorResumeNext(this Observable source, params Observable[] otherSources) - => RxSharp.Observable.OnErrorResumeNext(Prepend(source, otherSources)); + => ReactiveExtensionsSharp.Observable.OnErrorResumeNext(Prepend(source, otherSources)); private static Observable[] Prepend(Observable source, Observable[] otherSources) { diff --git a/src/RxSharp/Operators/Pairwise.cs b/src/ReactiveExtensionsSharp/Operators/Pairwise.cs similarity index 97% rename from src/RxSharp/Operators/Pairwise.cs rename to src/ReactiveExtensionsSharp/Operators/Pairwise.cs index 3a0a351..2ddb3a3 100644 --- a/src/RxSharp/Operators/Pairwise.cs +++ b/src/ReactiveExtensionsSharp/Operators/Pairwise.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the pairwise operator. public static class PairwiseOperator diff --git a/src/RxSharp/Operators/Partition.cs b/src/ReactiveExtensionsSharp/Operators/Partition.cs similarity index 98% rename from src/RxSharp/Operators/Partition.cs rename to src/ReactiveExtensionsSharp/Operators/Partition.cs index 30f7a4f..b1ad7e3 100644 --- a/src/RxSharp/Operators/Partition.cs +++ b/src/ReactiveExtensionsSharp/Operators/Partition.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Partition operator. Mirrors rxjs's partition. public static class PartitionOperator diff --git a/src/RxSharp/Operators/Race.cs b/src/ReactiveExtensionsSharp/Operators/Race.cs similarity index 97% rename from src/RxSharp/Operators/Race.cs rename to src/ReactiveExtensionsSharp/Operators/Race.cs index 9c37bf5..deebdad 100644 --- a/src/RxSharp/Operators/Race.cs +++ b/src/ReactiveExtensionsSharp/Operators/Race.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the raceWith operator. public static class RaceOperator diff --git a/src/RxSharp/Operators/Reduce.cs b/src/ReactiveExtensionsSharp/Operators/Reduce.cs similarity index 99% rename from src/RxSharp/Operators/Reduce.cs rename to src/ReactiveExtensionsSharp/Operators/Reduce.cs index 4929d83..4f0e231 100644 --- a/src/RxSharp/Operators/Reduce.cs +++ b/src/ReactiveExtensionsSharp/Operators/Reduce.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the reduce operator. /// diff --git a/src/RxSharp/Operators/Repeat.cs b/src/ReactiveExtensionsSharp/Operators/Repeat.cs similarity index 99% rename from src/RxSharp/Operators/Repeat.cs rename to src/ReactiveExtensionsSharp/Operators/Repeat.cs index d251bae..213fb97 100644 --- a/src/RxSharp/Operators/Repeat.cs +++ b/src/ReactiveExtensionsSharp/Operators/Repeat.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the repeat operator. /// diff --git a/src/RxSharp/Operators/RepeatWhen.cs b/src/ReactiveExtensionsSharp/Operators/RepeatWhen.cs similarity index 98% rename from src/RxSharp/Operators/RepeatWhen.cs rename to src/ReactiveExtensionsSharp/Operators/RepeatWhen.cs index 843c8ab..f8ae396 100644 --- a/src/RxSharp/Operators/RepeatWhen.cs +++ b/src/ReactiveExtensionsSharp/Operators/RepeatWhen.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the repeatWhen operator. /// diff --git a/src/RxSharp/Operators/Retry.cs b/src/ReactiveExtensionsSharp/Operators/Retry.cs similarity index 99% rename from src/RxSharp/Operators/Retry.cs rename to src/ReactiveExtensionsSharp/Operators/Retry.cs index e99b7d9..f75f2eb 100644 --- a/src/RxSharp/Operators/Retry.cs +++ b/src/ReactiveExtensionsSharp/Operators/Retry.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the retry operator. /// diff --git a/src/RxSharp/Operators/RetryWhen.cs b/src/ReactiveExtensionsSharp/Operators/RetryWhen.cs similarity index 98% rename from src/RxSharp/Operators/RetryWhen.cs rename to src/ReactiveExtensionsSharp/Operators/RetryWhen.cs index 56e9ba0..7d52e72 100644 --- a/src/RxSharp/Operators/RetryWhen.cs +++ b/src/ReactiveExtensionsSharp/Operators/RetryWhen.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the retryWhen operator. /// diff --git a/src/RxSharp/Operators/Sample.cs b/src/ReactiveExtensionsSharp/Operators/Sample.cs similarity index 99% rename from src/RxSharp/Operators/Sample.cs rename to src/ReactiveExtensionsSharp/Operators/Sample.cs index 0a54bf0..897fa6c 100644 --- a/src/RxSharp/Operators/Sample.cs +++ b/src/ReactiveExtensionsSharp/Operators/Sample.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The sample/sampleTime operators. public static class SampleOperator diff --git a/src/RxSharp/Operators/Scan.cs b/src/ReactiveExtensionsSharp/Operators/Scan.cs similarity index 99% rename from src/RxSharp/Operators/Scan.cs rename to src/ReactiveExtensionsSharp/Operators/Scan.cs index b235d79..e3d9286 100644 --- a/src/RxSharp/Operators/Scan.cs +++ b/src/ReactiveExtensionsSharp/Operators/Scan.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the scan operator. /// diff --git a/src/RxSharp/Operators/SequenceEqual.cs b/src/ReactiveExtensionsSharp/Operators/SequenceEqual.cs similarity index 99% rename from src/RxSharp/Operators/SequenceEqual.cs rename to src/ReactiveExtensionsSharp/Operators/SequenceEqual.cs index 2a88b27..1fed0b6 100644 --- a/src/RxSharp/Operators/SequenceEqual.cs +++ b/src/ReactiveExtensionsSharp/Operators/SequenceEqual.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the SequenceEqual operator. Mirrors rxjs's sequenceEqual. public static class SequenceEqualOperator diff --git a/src/RxSharp/Operators/Share.cs b/src/ReactiveExtensionsSharp/Operators/Share.cs similarity index 96% rename from src/RxSharp/Operators/Share.cs rename to src/ReactiveExtensionsSharp/Operators/Share.cs index 69bc446..19e75e7 100644 --- a/src/RxSharp/Operators/Share.cs +++ b/src/ReactiveExtensionsSharp/Operators/Share.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Share operator. Mirrors rxjs's share() with its default config. public static class ShareOperator diff --git a/src/RxSharp/Operators/ShareConfig.cs b/src/ReactiveExtensionsSharp/Operators/ShareConfig.cs similarity index 96% rename from src/RxSharp/Operators/ShareConfig.cs rename to src/ReactiveExtensionsSharp/Operators/ShareConfig.cs index facea5e..0b0798b 100644 --- a/src/RxSharp/Operators/ShareConfig.cs +++ b/src/ReactiveExtensionsSharp/Operators/ShareConfig.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// /// Configuration object for the overload, @@ -14,7 +14,7 @@ namespace RxSharp.Operators; /// factory ((error?) => ObservableInput<any>) for each, letting the reset be delayed/conditional on /// some other observable emitting. That variant is not implemented -- it adds substantial complexity (async/deferred /// reset timing, unhandled-error-on-notifier-error semantics) for a corner of the API this port's target use case -/// (Puppeteer-style retry/timeout combinators) never needs. already carried this +/// (Puppeteer-style retry/timeout combinators) never needs. already carried this /// same "boolean case only" note for the completion knob before this config object existed; it now applies /// uniformly to all three reset knobs. /// diff --git a/src/RxSharp/Operators/ShareReplay.cs b/src/ReactiveExtensionsSharp/Operators/ShareReplay.cs similarity index 96% rename from src/RxSharp/Operators/ShareReplay.cs rename to src/ReactiveExtensionsSharp/Operators/ShareReplay.cs index e0c3dee..bcb44fa 100644 --- a/src/RxSharp/Operators/ShareReplay.cs +++ b/src/ReactiveExtensionsSharp/Operators/ShareReplay.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the ShareReplay operator. Mirrors rxjs's shareReplay(). public static class ShareReplayOperator diff --git a/src/RxSharp/Operators/Single.cs b/src/ReactiveExtensionsSharp/Operators/Single.cs similarity index 99% rename from src/RxSharp/Operators/Single.cs rename to src/ReactiveExtensionsSharp/Operators/Single.cs index 6598728..6bb4161 100644 --- a/src/RxSharp/Operators/Single.cs +++ b/src/ReactiveExtensionsSharp/Operators/Single.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Single operator. Mirrors rxjs's single. public static class SingleOperator diff --git a/src/RxSharp/Operators/Skip.cs b/src/ReactiveExtensionsSharp/Operators/Skip.cs similarity index 98% rename from src/RxSharp/Operators/Skip.cs rename to src/ReactiveExtensionsSharp/Operators/Skip.cs index 231dbac..c7db022 100644 --- a/src/RxSharp/Operators/Skip.cs +++ b/src/ReactiveExtensionsSharp/Operators/Skip.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the Skip operator. Mirrors rxjs's skip. public static class SkipOperator diff --git a/src/RxSharp/Operators/SkipLast.cs b/src/ReactiveExtensionsSharp/Operators/SkipLast.cs similarity index 97% rename from src/RxSharp/Operators/SkipLast.cs rename to src/ReactiveExtensionsSharp/Operators/SkipLast.cs index 59f37ac..7e35cd2 100644 --- a/src/RxSharp/Operators/SkipLast.cs +++ b/src/ReactiveExtensionsSharp/Operators/SkipLast.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the SkipLast operator. Mirrors rxjs's skipLast. public static class SkipLastOperator diff --git a/src/RxSharp/Operators/SkipUntil.cs b/src/ReactiveExtensionsSharp/Operators/SkipUntil.cs similarity index 98% rename from src/RxSharp/Operators/SkipUntil.cs rename to src/ReactiveExtensionsSharp/Operators/SkipUntil.cs index 30588fe..56405d4 100644 --- a/src/RxSharp/Operators/SkipUntil.cs +++ b/src/ReactiveExtensionsSharp/Operators/SkipUntil.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the skipUntil operator. public static class SkipUntilOperator diff --git a/src/RxSharp/Operators/SkipWhile.cs b/src/ReactiveExtensionsSharp/Operators/SkipWhile.cs similarity index 98% rename from src/RxSharp/Operators/SkipWhile.cs rename to src/ReactiveExtensionsSharp/Operators/SkipWhile.cs index 66122d8..ebf313d 100644 --- a/src/RxSharp/Operators/SkipWhile.cs +++ b/src/ReactiveExtensionsSharp/Operators/SkipWhile.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the SkipWhile operator. Mirrors rxjs's skipWhile. public static class SkipWhileOperator diff --git a/src/RxSharp/Operators/StartWith.cs b/src/ReactiveExtensionsSharp/Operators/StartWith.cs similarity index 97% rename from src/RxSharp/Operators/StartWith.cs rename to src/ReactiveExtensionsSharp/Operators/StartWith.cs index 7951a7b..1a0dc80 100644 --- a/src/RxSharp/Operators/StartWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/StartWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the startWith operator. public static class StartWithOperator diff --git a/src/RxSharp/Operators/SwitchAll.cs b/src/ReactiveExtensionsSharp/Operators/SwitchAll.cs similarity index 95% rename from src/RxSharp/Operators/SwitchAll.cs rename to src/ReactiveExtensionsSharp/Operators/SwitchAll.cs index 2f5f6cf..ea77248 100644 --- a/src/RxSharp/Operators/SwitchAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/SwitchAll.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the switchAll operator. public static class SwitchAllOperator diff --git a/src/RxSharp/Operators/SwitchMap.cs b/src/ReactiveExtensionsSharp/Operators/SwitchMap.cs similarity index 99% rename from src/RxSharp/Operators/SwitchMap.cs rename to src/ReactiveExtensionsSharp/Operators/SwitchMap.cs index 80f897c..9360ccc 100644 --- a/src/RxSharp/Operators/SwitchMap.cs +++ b/src/ReactiveExtensionsSharp/Operators/SwitchMap.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the switchMap operator. public static class SwitchMapOperator diff --git a/src/RxSharp/Operators/SwitchMapTo.cs b/src/ReactiveExtensionsSharp/Operators/SwitchMapTo.cs similarity index 97% rename from src/RxSharp/Operators/SwitchMapTo.cs rename to src/ReactiveExtensionsSharp/Operators/SwitchMapTo.cs index 2104af3..5c6ee26 100644 --- a/src/RxSharp/Operators/SwitchMapTo.cs +++ b/src/ReactiveExtensionsSharp/Operators/SwitchMapTo.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the switchMapTo operator. public static class SwitchMapToOperator diff --git a/src/RxSharp/Operators/SwitchScan.cs b/src/ReactiveExtensionsSharp/Operators/SwitchScan.cs similarity index 99% rename from src/RxSharp/Operators/SwitchScan.cs rename to src/ReactiveExtensionsSharp/Operators/SwitchScan.cs index 9fe6bad..2894607 100644 --- a/src/RxSharp/Operators/SwitchScan.cs +++ b/src/ReactiveExtensionsSharp/Operators/SwitchScan.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the switchScan operator. public static class SwitchScanOperator diff --git a/src/RxSharp/Operators/Take.cs b/src/ReactiveExtensionsSharp/Operators/Take.cs similarity index 98% rename from src/RxSharp/Operators/Take.cs rename to src/ReactiveExtensionsSharp/Operators/Take.cs index d1929b7..0e15d49 100644 --- a/src/RxSharp/Operators/Take.cs +++ b/src/ReactiveExtensionsSharp/Operators/Take.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the take operator. public static class TakeOperator diff --git a/src/RxSharp/Operators/TakeLast.cs b/src/ReactiveExtensionsSharp/Operators/TakeLast.cs similarity index 98% rename from src/RxSharp/Operators/TakeLast.cs rename to src/ReactiveExtensionsSharp/Operators/TakeLast.cs index 6bc2bf2..a0ee65d 100644 --- a/src/RxSharp/Operators/TakeLast.cs +++ b/src/ReactiveExtensionsSharp/Operators/TakeLast.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the TakeLast operator. Mirrors rxjs's takeLast. public static class TakeLastOperator diff --git a/src/RxSharp/Operators/TakeUntil.cs b/src/ReactiveExtensionsSharp/Operators/TakeUntil.cs similarity index 98% rename from src/RxSharp/Operators/TakeUntil.cs rename to src/ReactiveExtensionsSharp/Operators/TakeUntil.cs index d0a6a7b..08c766b 100644 --- a/src/RxSharp/Operators/TakeUntil.cs +++ b/src/ReactiveExtensionsSharp/Operators/TakeUntil.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the takeUntil operator. public static class TakeUntilOperator diff --git a/src/RxSharp/Operators/TakeWhile.cs b/src/ReactiveExtensionsSharp/Operators/TakeWhile.cs similarity index 98% rename from src/RxSharp/Operators/TakeWhile.cs rename to src/ReactiveExtensionsSharp/Operators/TakeWhile.cs index 5f32e1a..621b56d 100644 --- a/src/RxSharp/Operators/TakeWhile.cs +++ b/src/ReactiveExtensionsSharp/Operators/TakeWhile.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the TakeWhile operator. Mirrors rxjs's takeWhile. public static class TakeWhileOperator diff --git a/src/RxSharp/Operators/Tap.cs b/src/ReactiveExtensionsSharp/Operators/Tap.cs similarity index 98% rename from src/RxSharp/Operators/Tap.cs rename to src/ReactiveExtensionsSharp/Operators/Tap.cs index 5cf4d28..52f5345 100644 --- a/src/RxSharp/Operators/Tap.cs +++ b/src/ReactiveExtensionsSharp/Operators/Tap.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the tap operator. public static class TapOperator diff --git a/src/RxSharp/Operators/Throttle.cs b/src/ReactiveExtensionsSharp/Operators/Throttle.cs similarity index 99% rename from src/RxSharp/Operators/Throttle.cs rename to src/ReactiveExtensionsSharp/Operators/Throttle.cs index bb01566..24d9d7c 100644 --- a/src/RxSharp/Operators/Throttle.cs +++ b/src/ReactiveExtensionsSharp/Operators/Throttle.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The throttle/throttleTime operators. public static class ThrottleOperator diff --git a/src/RxSharp/Operators/ThrowIfEmpty.cs b/src/ReactiveExtensionsSharp/Operators/ThrowIfEmpty.cs similarity index 97% rename from src/RxSharp/Operators/ThrowIfEmpty.cs rename to src/ReactiveExtensionsSharp/Operators/ThrowIfEmpty.cs index c1e185e..6e7aa5f 100644 --- a/src/RxSharp/Operators/ThrowIfEmpty.cs +++ b/src/ReactiveExtensionsSharp/Operators/ThrowIfEmpty.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the throwIfEmpty operator. public static class ThrowIfEmptyOperator diff --git a/src/RxSharp/Operators/TimeInterval.cs b/src/ReactiveExtensionsSharp/Operators/TimeInterval.cs similarity index 87% rename from src/RxSharp/Operators/TimeInterval.cs rename to src/ReactiveExtensionsSharp/Operators/TimeInterval.cs index d49b7ff..33a2ebc 100644 --- a/src/RxSharp/Operators/TimeInterval.cs +++ b/src/ReactiveExtensionsSharp/Operators/TimeInterval.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the timeInterval operator. public static class TimeIntervalOperator @@ -11,7 +11,7 @@ public static class TimeIntervalOperator /// The type of values emitted by . /// The source sequence. /// The scheduler whose is used to time each emission; defaults to when . - /// An observable of values pairing each source value with the time elapsed since the previous one. + /// An observable of values pairing each source value with the time elapsed since the previous one. public static Observable> TimeInterval(this Observable source, IScheduler? scheduler = null) => source.Operate>((src, subscriber) => { diff --git a/src/RxSharp/Operators/Timestamp.cs b/src/ReactiveExtensionsSharp/Operators/Timestamp.cs similarity index 83% rename from src/RxSharp/Operators/Timestamp.cs rename to src/ReactiveExtensionsSharp/Operators/Timestamp.cs index 01fa92d..654622b 100644 --- a/src/RxSharp/Operators/Timestamp.cs +++ b/src/ReactiveExtensionsSharp/Operators/Timestamp.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the timestamp operator. public static class TimestampOperator @@ -10,7 +10,7 @@ public static class TimestampOperator /// The type of values emitted by . /// The source sequence. /// The scheduler whose is used to time each emission; defaults to when . - /// An observable of values pairing each source value with the time it was received. + /// An observable of values pairing each source value with the time it was received. public static Observable> Timestamp(this Observable source, IScheduler? scheduler = null) { var activeScheduler = scheduler ?? TaskPoolScheduler.Instance; diff --git a/src/RxSharp/Operators/ToArray.cs b/src/ReactiveExtensionsSharp/Operators/ToArray.cs similarity index 96% rename from src/RxSharp/Operators/ToArray.cs rename to src/ReactiveExtensionsSharp/Operators/ToArray.cs index 749ca3a..c04a0db 100644 --- a/src/RxSharp/Operators/ToArray.cs +++ b/src/ReactiveExtensionsSharp/Operators/ToArray.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Implements the ToArray operator. Mirrors rxjs's toArray. public static class ToArrayOperator diff --git a/src/RxSharp/Operators/Window.cs b/src/ReactiveExtensionsSharp/Operators/Window.cs similarity index 96% rename from src/RxSharp/Operators/Window.cs rename to src/ReactiveExtensionsSharp/Operators/Window.cs index ddaa852..8587c12 100644 --- a/src/RxSharp/Operators/Window.cs +++ b/src/ReactiveExtensionsSharp/Operators/Window.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The window operator. public static class WindowOperator diff --git a/src/RxSharp/Operators/WindowCount.cs b/src/ReactiveExtensionsSharp/Operators/WindowCount.cs similarity index 97% rename from src/RxSharp/Operators/WindowCount.cs rename to src/ReactiveExtensionsSharp/Operators/WindowCount.cs index b47d014..8c80e41 100644 --- a/src/RxSharp/Operators/WindowCount.cs +++ b/src/ReactiveExtensionsSharp/Operators/WindowCount.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The windowCount operator. public static class WindowCountOperator diff --git a/src/RxSharp/Operators/WindowTime.cs b/src/ReactiveExtensionsSharp/Operators/WindowTime.cs similarity index 98% rename from src/RxSharp/Operators/WindowTime.cs rename to src/ReactiveExtensionsSharp/Operators/WindowTime.cs index e3c0c0e..75b61a6 100644 --- a/src/RxSharp/Operators/WindowTime.cs +++ b/src/ReactiveExtensionsSharp/Operators/WindowTime.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The windowTime operator. public static class WindowTimeOperator diff --git a/src/RxSharp/Operators/WindowWhen.cs b/src/ReactiveExtensionsSharp/Operators/WindowWhen.cs similarity index 98% rename from src/RxSharp/Operators/WindowWhen.cs rename to src/ReactiveExtensionsSharp/Operators/WindowWhen.cs index f9d7103..80fc534 100644 --- a/src/RxSharp/Operators/WindowWhen.cs +++ b/src/ReactiveExtensionsSharp/Operators/WindowWhen.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// The windowWhen operator. public static class WindowWhenOperator diff --git a/src/RxSharp/Operators/WithLatestFrom.cs b/src/ReactiveExtensionsSharp/Operators/WithLatestFrom.cs similarity index 99% rename from src/RxSharp/Operators/WithLatestFrom.cs rename to src/ReactiveExtensionsSharp/Operators/WithLatestFrom.cs index d017e93..1bd87fe 100644 --- a/src/RxSharp/Operators/WithLatestFrom.cs +++ b/src/ReactiveExtensionsSharp/Operators/WithLatestFrom.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the withLatestFrom operator. public static class WithLatestFromOperator diff --git a/src/RxSharp/Operators/ZipAll.cs b/src/ReactiveExtensionsSharp/Operators/ZipAll.cs similarity index 69% rename from src/RxSharp/Operators/ZipAll.cs rename to src/ReactiveExtensionsSharp/Operators/ZipAll.cs index 9b4a1fb..718905a 100644 --- a/src/RxSharp/Operators/ZipAll.cs +++ b/src/ReactiveExtensionsSharp/Operators/ZipAll.cs @@ -1,21 +1,21 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the zipAll operator. public static class ZipAllOperator { /// /// Collects every inner observable produced by and, once - /// completes, combines all of them with : the Nth value from every + /// completes, combines all of them with : the Nth value from every /// collected inner observable is combined into a single emitted list, positionally. Ported from rxjs's /// joinAllInternals applied to zip: source.ToArray().MergeMap(sources => Zip(sources)). /// /// - /// Same-type-only, like itself — see 's + /// Same-type-only, like itself — see 's /// remarks for why no project parameter is ported. /// /// The type of values emitted by the inner observables. /// The higher-order source sequence. /// An observable that emits a list of the Nth value from every collected inner observable, in order. public static Observable> ZipAll(this Observable> source) - => source.ToArray().MergeMap(sources => RxSharp.Observable.Zip(sources.ToArray())); + => source.ToArray().MergeMap(sources => ReactiveExtensionsSharp.Observable.Zip(sources.ToArray())); } diff --git a/src/RxSharp/Operators/ZipWith.cs b/src/ReactiveExtensionsSharp/Operators/ZipWith.cs similarity index 80% rename from src/RxSharp/Operators/ZipWith.cs rename to src/ReactiveExtensionsSharp/Operators/ZipWith.cs index 2897ebf..7f79db9 100644 --- a/src/RxSharp/Operators/ZipWith.cs +++ b/src/ReactiveExtensionsSharp/Operators/ZipWith.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Operators; +namespace ReactiveExtensionsSharp.Operators; /// Extension methods implementing the zipWith operator. public static class ZipWithOperator @@ -6,11 +6,11 @@ public static class ZipWithOperator /// /// Subscribes to and every one of , combining the /// Nth value of each into a single emitted list, positionally. Pipeable-operator sugar over - /// with prepended: + /// with prepended: /// source.ZipWith(a, b) is the same as Observable.Zip(source, a, b). /// /// - /// Same-type-only, like itself, rather than rxjs's + /// Same-type-only, like itself, rather than rxjs's /// heterogeneously-typed tuple result. /// /// The type of values shared by and . @@ -18,7 +18,7 @@ public static class ZipWithOperator /// The other sequences to zip with . /// An observable that emits a list of the Nth value from and every one of , in order. public static Observable> ZipWith(this Observable source, params Observable[] otherSources) - => RxSharp.Observable.Zip(Prepend(source, otherSources)); + => ReactiveExtensionsSharp.Observable.Zip(Prepend(source, otherSources)); private static Observable[] Prepend(Observable source, Observable[] otherSources) { diff --git a/src/RxSharp/RaceCore.cs b/src/ReactiveExtensionsSharp/RaceCore.cs similarity index 98% rename from src/RxSharp/RaceCore.cs rename to src/ReactiveExtensionsSharp/RaceCore.cs index 326c862..e4244da 100644 --- a/src/RxSharp/RaceCore.cs +++ b/src/ReactiveExtensionsSharp/RaceCore.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Shared "first to emit wins" subscription logic used by Observable.Race and the RaceWith operator. internal static class RaceCore diff --git a/src/RxSharp/RxSharp.csproj b/src/ReactiveExtensionsSharp/ReactiveExtensionsSharp.csproj similarity index 94% rename from src/RxSharp/RxSharp.csproj rename to src/ReactiveExtensionsSharp/ReactiveExtensionsSharp.csproj index d09bcff..8f9689a 100644 --- a/src/RxSharp/RxSharp.csproj +++ b/src/ReactiveExtensionsSharp/ReactiveExtensionsSharp.csproj @@ -8,7 +8,7 @@ ReactiveExtensionsSharp - RxSharp + ReactiveExtensionsSharp Darío Kondratiuk A .NET port of RxJS (Reactive Extensions for JavaScript). rxjs;reactive;observable;rx;async @@ -16,9 +16,9 @@ https://github.com/hardkoded/ReactiveExtensions-Sharp https://github.com/hardkoded/ReactiveExtensions-Sharp README.md - 0.1.4 - 0.1.4.0 - 0.1.4.0 + 0.2.0 + 0.2.0.0 + 0.2.0.0 diff --git a/src/RxSharp/RxConfig.cs b/src/ReactiveExtensionsSharp/RxConfig.cs similarity index 96% rename from src/RxSharp/RxConfig.cs rename to src/ReactiveExtensionsSharp/RxConfig.cs index 7669dae..f67a046 100644 --- a/src/RxSharp/RxConfig.cs +++ b/src/ReactiveExtensionsSharp/RxConfig.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Global, mutable configuration hooks. Mirrors rxjs's config module. diff --git a/src/RxSharp/SequenceErrorException.cs b/src/ReactiveExtensionsSharp/SequenceErrorException.cs similarity index 95% rename from src/RxSharp/SequenceErrorException.cs rename to src/ReactiveExtensionsSharp/SequenceErrorException.cs index 290a640..cbdf440 100644 --- a/src/RxSharp/SequenceErrorException.cs +++ b/src/ReactiveExtensionsSharp/SequenceErrorException.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Thrown by Single when more than one value (or more than one predicate match) is seen from the source. diff --git a/src/RxSharp/ShareCore.cs b/src/ReactiveExtensionsSharp/ShareCore.cs similarity index 97% rename from src/RxSharp/ShareCore.cs rename to src/ReactiveExtensionsSharp/ShareCore.cs index 6475a07..bfe0773 100644 --- a/src/RxSharp/ShareCore.cs +++ b/src/ReactiveExtensionsSharp/ShareCore.cs @@ -1,13 +1,13 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Shared multicast/reset subscription logic behind the Share and ShareReplay operators. Connects /// to the source on the first subscriber. Each of the three reset triggers (source error, source completion, /// subscriber count dropping back to zero) is independently configurable via a plain -- this /// port doesn't implement rxjs's reset-notifier-observable knobs, just the common boolean case (see -/// 's remarks for why). +/// 's remarks for why). /// internal static class ShareCore { diff --git a/src/RxSharp/SingleAssignmentDisposable.cs b/src/ReactiveExtensionsSharp/SingleAssignmentDisposable.cs similarity index 98% rename from src/RxSharp/SingleAssignmentDisposable.cs rename to src/ReactiveExtensionsSharp/SingleAssignmentDisposable.cs index 2f102b7..e08f56a 100644 --- a/src/RxSharp/SingleAssignmentDisposable.cs +++ b/src/ReactiveExtensionsSharp/SingleAssignmentDisposable.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// An whose target is assigned after construction. Disposing before the diff --git a/src/RxSharp/Subjects/AsyncSubject.cs b/src/ReactiveExtensionsSharp/Subjects/AsyncSubject.cs similarity index 98% rename from src/RxSharp/Subjects/AsyncSubject.cs rename to src/ReactiveExtensionsSharp/Subjects/AsyncSubject.cs index 1379092..8268fbe 100644 --- a/src/RxSharp/Subjects/AsyncSubject.cs +++ b/src/ReactiveExtensionsSharp/Subjects/AsyncSubject.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Subjects; +namespace ReactiveExtensionsSharp.Subjects; /// /// A that only emits its last nexted value, and only upon completion. If it errors diff --git a/src/RxSharp/Subjects/BehaviorSubject.cs b/src/ReactiveExtensionsSharp/Subjects/BehaviorSubject.cs similarity index 98% rename from src/RxSharp/Subjects/BehaviorSubject.cs rename to src/ReactiveExtensionsSharp/Subjects/BehaviorSubject.cs index 64e7c57..8d612c4 100644 --- a/src/RxSharp/Subjects/BehaviorSubject.cs +++ b/src/ReactiveExtensionsSharp/Subjects/BehaviorSubject.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Subjects; +namespace ReactiveExtensionsSharp.Subjects; /// /// A that requires an initial value and synchronously replays its current value to every diff --git a/src/RxSharp/Subjects/ReplaySubject.cs b/src/ReactiveExtensionsSharp/Subjects/ReplaySubject.cs similarity index 98% rename from src/RxSharp/Subjects/ReplaySubject.cs rename to src/ReactiveExtensionsSharp/Subjects/ReplaySubject.cs index 6b844b6..867bf1d 100644 --- a/src/RxSharp/Subjects/ReplaySubject.cs +++ b/src/ReactiveExtensionsSharp/Subjects/ReplaySubject.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Subjects; +namespace ReactiveExtensionsSharp.Subjects; /// /// A that buffers emitted values and replays them to new subscribers before they start diff --git a/src/RxSharp/Subjects/Subject.cs b/src/ReactiveExtensionsSharp/Subjects/Subject.cs similarity index 97% rename from src/RxSharp/Subjects/Subject.cs rename to src/ReactiveExtensionsSharp/Subjects/Subject.cs index 267d2f9..ffeb135 100644 --- a/src/RxSharp/Subjects/Subject.cs +++ b/src/ReactiveExtensionsSharp/Subjects/Subject.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Subjects; +namespace ReactiveExtensionsSharp.Subjects; /// /// A multicast that is also an : every value/error/completion @@ -20,7 +20,7 @@ public class Subject : IObservable, IObserver, IDisposable /// /// Gets a value indicating whether the subject has already terminated via or - /// . Exposed to subclasses (see ) so they + /// . Exposed to subclasses (see ) so they /// can consult the terminal state for their own bookkeeping — e.g. to avoid buffering a value that arrives after /// termination, even though it is correctly no longer forwarded to subscribers. /// @@ -37,7 +37,7 @@ protected bool IsStopped /// /// Gets a value indicating whether the subject has already terminated via . Exposed to - /// subclasses (see , ) + /// subclasses (see , ) /// so they can consult the error state for their own bookkeeping. /// protected bool HasError diff --git a/src/RxSharp/Subscriber.cs b/src/ReactiveExtensionsSharp/Subscriber.cs similarity index 96% rename from src/RxSharp/Subscriber.cs rename to src/ReactiveExtensionsSharp/Subscriber.cs index c8fab27..1448a40 100644 --- a/src/RxSharp/Subscriber.cs +++ b/src/ReactiveExtensionsSharp/Subscriber.cs @@ -1,10 +1,10 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// Wraps an with unsubscribe-aware, re-entrancy-guarded dispatch. Mirrors rxjs's Subscriber. /// Deliberately does not swallow exceptions thrown by the wrapped observer's callbacks: it is each operator's own /// responsibility to catch exceptions from user-supplied callbacks (projections, predicates, side effects) and -/// forward them via — see RxSharp/Operators for the pattern. A generic catch-and-forward +/// forward them via — see ReactiveExtensionsSharp/Operators for the pattern. A generic catch-and-forward /// here would double up across nested operator chains and silently swallow errors instead of propagating them. /// /// The type of the values this subscriber accepts. diff --git a/src/RxSharp/Subscription.cs b/src/ReactiveExtensionsSharp/Subscription.cs similarity index 99% rename from src/RxSharp/Subscription.cs rename to src/ReactiveExtensionsSharp/Subscription.cs index f1a6ba0..e194303 100644 --- a/src/RxSharp/Subscription.cs +++ b/src/ReactiveExtensionsSharp/Subscription.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// A disposable that composes child teardown logic. Mirrors rxjs's Subscription. public class Subscription : IDisposable diff --git a/src/RxSharp/TaskPoolScheduler.cs b/src/ReactiveExtensionsSharp/TaskPoolScheduler.cs similarity index 97% rename from src/RxSharp/TaskPoolScheduler.cs rename to src/ReactiveExtensionsSharp/TaskPoolScheduler.cs index cb9ce46..1fdd493 100644 --- a/src/RxSharp/TaskPoolScheduler.cs +++ b/src/ReactiveExtensionsSharp/TaskPoolScheduler.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// The default , backed by . public sealed class TaskPoolScheduler : IScheduler diff --git a/src/RxSharp/Testing/MarbleParser.cs b/src/ReactiveExtensionsSharp/Testing/MarbleParser.cs similarity index 98% rename from src/RxSharp/Testing/MarbleParser.cs rename to src/ReactiveExtensionsSharp/Testing/MarbleParser.cs index 8df2907..ce5324c 100644 --- a/src/RxSharp/Testing/MarbleParser.cs +++ b/src/ReactiveExtensionsSharp/Testing/MarbleParser.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Testing; +namespace ReactiveExtensionsSharp.Testing; /// /// Parses rxjs-style ASCII marble diagrams into timestamped messages. Each character diff --git a/src/RxSharp/Testing/Recorded.cs b/src/ReactiveExtensionsSharp/Testing/Recorded.cs similarity index 99% rename from src/RxSharp/Testing/Recorded.cs rename to src/ReactiveExtensionsSharp/Testing/Recorded.cs index e95d0f4..8f5ccfa 100644 --- a/src/RxSharp/Testing/Recorded.cs +++ b/src/ReactiveExtensionsSharp/Testing/Recorded.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Testing; +namespace ReactiveExtensionsSharp.Testing; /// /// A single timestamped notification (next/error/complete), stamped with a 's diff --git a/src/RxSharp/Testing/RecordedKind.cs b/src/ReactiveExtensionsSharp/Testing/RecordedKind.cs similarity index 90% rename from src/RxSharp/Testing/RecordedKind.cs rename to src/ReactiveExtensionsSharp/Testing/RecordedKind.cs index 54a6935..200cbf5 100644 --- a/src/RxSharp/Testing/RecordedKind.cs +++ b/src/ReactiveExtensionsSharp/Testing/RecordedKind.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Testing; +namespace ReactiveExtensionsSharp.Testing; /// The kind of notification captured by a . Mirrors rxjs's NotificationKind. public enum RecordedKind diff --git a/src/RxSharp/Testing/TestScheduler.cs b/src/ReactiveExtensionsSharp/Testing/TestScheduler.cs similarity index 98% rename from src/RxSharp/Testing/TestScheduler.cs rename to src/ReactiveExtensionsSharp/Testing/TestScheduler.cs index 5f0a618..a94d600 100644 --- a/src/RxSharp/Testing/TestScheduler.cs +++ b/src/ReactiveExtensionsSharp/Testing/TestScheduler.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Testing; +namespace ReactiveExtensionsSharp.Testing; /// /// A that additionally understands rxjs-style ASCII marble diagrams, so diff --git a/src/RxSharp/Testing/VirtualTimeScheduler.cs b/src/ReactiveExtensionsSharp/Testing/VirtualTimeScheduler.cs similarity index 99% rename from src/RxSharp/Testing/VirtualTimeScheduler.cs rename to src/ReactiveExtensionsSharp/Testing/VirtualTimeScheduler.cs index c7d85f8..3a71a99 100644 --- a/src/RxSharp/Testing/VirtualTimeScheduler.cs +++ b/src/ReactiveExtensionsSharp/Testing/VirtualTimeScheduler.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Testing; +namespace ReactiveExtensionsSharp.Testing; /// /// An that tracks a virtual clock instead of real time. never diff --git a/src/RxSharp/TimeInterval.cs b/src/ReactiveExtensionsSharp/TimeInterval.cs similarity index 98% rename from src/RxSharp/TimeInterval.cs rename to src/ReactiveExtensionsSharp/TimeInterval.cs index 7b68b38..1caf2df 100644 --- a/src/RxSharp/TimeInterval.cs +++ b/src/ReactiveExtensionsSharp/TimeInterval.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// A value tagged with the time elapsed since the previous emission (or since subscription, for the first diff --git a/src/RxSharp/Timestamp.cs b/src/ReactiveExtensionsSharp/Timestamp.cs similarity index 98% rename from src/RxSharp/Timestamp.cs rename to src/ReactiveExtensionsSharp/Timestamp.cs index de95def..d715dc2 100644 --- a/src/RxSharp/Timestamp.cs +++ b/src/ReactiveExtensionsSharp/Timestamp.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// /// A value tagged with the wall-clock time it was received. Produced by diff --git a/src/RxSharp/Unit.cs b/src/ReactiveExtensionsSharp/Unit.cs similarity index 97% rename from src/RxSharp/Unit.cs rename to src/ReactiveExtensionsSharp/Unit.cs index 488acbc..154b6a0 100644 --- a/src/RxSharp/Unit.cs +++ b/src/ReactiveExtensionsSharp/Unit.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Stands in for rxjs's never type parameter (e.g. streams that only ever error or complete). public readonly struct Unit : IEquatable diff --git a/src/RxSharp/UnsubscriptionException.cs b/src/ReactiveExtensionsSharp/UnsubscriptionException.cs similarity index 96% rename from src/RxSharp/UnsubscriptionException.cs rename to src/ReactiveExtensionsSharp/UnsubscriptionException.cs index 287b455..1c0ec5f 100644 --- a/src/RxSharp/UnsubscriptionException.cs +++ b/src/ReactiveExtensionsSharp/UnsubscriptionException.cs @@ -1,4 +1,4 @@ -namespace RxSharp; +namespace ReactiveExtensionsSharp; /// Raised when one or more finalizers throw while a is being disposed. Mirrors rxjs's UnsubscriptionError. public sealed class UnsubscriptionException : Exception diff --git a/src/RxSharp/stylecop.json b/src/ReactiveExtensionsSharp/stylecop.json similarity index 100% rename from src/RxSharp/stylecop.json rename to src/ReactiveExtensionsSharp/stylecop.json diff --git a/test/RxSharp.Tests/AsyncBridgeTests.cs b/test/ReactiveExtensionsSharp.Tests/AsyncBridgeTests.cs similarity index 97% rename from test/RxSharp.Tests/AsyncBridgeTests.cs rename to test/ReactiveExtensionsSharp.Tests/AsyncBridgeTests.cs index 0fbff6c..dce7653 100644 --- a/test/RxSharp.Tests/AsyncBridgeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/AsyncBridgeTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported (non-marble subset) from rxjs 7.8.2 spec/firstValueFrom-spec.ts and spec/lastValueFrom-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/BindCallbackTests.cs b/test/ReactiveExtensionsSharp.Tests/BindCallbackTests.cs similarity index 99% rename from test/RxSharp.Tests/BindCallbackTests.cs rename to test/ReactiveExtensionsSharp.Tests/BindCallbackTests.cs index 86f142d..a769b43 100644 --- a/test/RxSharp.Tests/BindCallbackTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/BindCallbackTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; /// /// Ported from rxjs's bindCallback-spec.ts (tag 7.8.2). The "when scheduled" describe block and the diff --git a/test/RxSharp.Tests/BindNodeCallbackTests.cs b/test/ReactiveExtensionsSharp.Tests/BindNodeCallbackTests.cs similarity index 99% rename from test/RxSharp.Tests/BindNodeCallbackTests.cs rename to test/ReactiveExtensionsSharp.Tests/BindNodeCallbackTests.cs index 815f740..21b4ff7 100644 --- a/test/RxSharp.Tests/BindNodeCallbackTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/BindNodeCallbackTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; /// /// Ported from rxjs's bindNodeCallback-spec.ts (tag 7.8.2). The "when scheduled" describe block and the diff --git a/test/RxSharp.Tests/CombineLatestTests.cs b/test/ReactiveExtensionsSharp.Tests/CombineLatestTests.cs similarity index 96% rename from test/RxSharp.Tests/CombineLatestTests.cs rename to test/ReactiveExtensionsSharp.Tests/CombineLatestTests.cs index 773c3ea..898921d 100644 --- a/test/RxSharp.Tests/CombineLatestTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/CombineLatestTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/combineLatest-spec.ts. [TestFixture] @@ -54,7 +54,7 @@ public void ShouldCompleteWhenAllSourcesCompleteWithoutEverEmitting() // rxjs's "should work with empty and never": a source completing without a value must NOT eagerly complete // the whole combineLatest while another source is still active -- it must keep waiting on it (even though - // the result can now never emit). This is the exact bug found and fixed while porting this test: the RxSharp + // the result can now never emit). This is the exact bug found and fixed while porting this test: the ReactiveExtensionsSharp // implementation used to short-circuit on `!hasValue[index]` the same way ForkJoin legitimately does, but // real rxjs's combineLatestInit has no such special case (see Observable.Creation.cs's CombineLatest remarks). [Test] diff --git a/test/RxSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs b/test/ReactiveExtensionsSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs similarity index 95% rename from test/RxSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs rename to test/ReactiveExtensionsSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs index d84c309..5cc3bd7 100644 --- a/test/RxSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Extras/AssumeNeverEmitsExtrasTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Extras; +namespace ReactiveExtensionsSharp.Tests.Extras; [TestFixture] public class AssumeNeverEmitsExtrasTests diff --git a/test/RxSharp.Tests/Extras/CancellationExtrasTests.cs b/test/ReactiveExtensionsSharp.Tests/Extras/CancellationExtrasTests.cs similarity index 94% rename from test/RxSharp.Tests/Extras/CancellationExtrasTests.cs rename to test/ReactiveExtensionsSharp.Tests/Extras/CancellationExtrasTests.cs index 052be97..96def18 100644 --- a/test/RxSharp.Tests/Extras/CancellationExtrasTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Extras/CancellationExtrasTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Extras; +namespace ReactiveExtensionsSharp.Tests.Extras; [TestFixture] public class CancellationExtrasTests diff --git a/test/RxSharp.Tests/Extras/FilterAsyncExtrasTests.cs b/test/ReactiveExtensionsSharp.Tests/Extras/FilterAsyncExtrasTests.cs similarity index 94% rename from test/RxSharp.Tests/Extras/FilterAsyncExtrasTests.cs rename to test/ReactiveExtensionsSharp.Tests/Extras/FilterAsyncExtrasTests.cs index bd2e6fa..92407ce 100644 --- a/test/RxSharp.Tests/Extras/FilterAsyncExtrasTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Extras/FilterAsyncExtrasTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Extras; +namespace ReactiveExtensionsSharp.Tests.Extras; [TestFixture] public class FilterAsyncExtrasTests diff --git a/test/RxSharp.Tests/Extras/FromEventBufferedExtrasTests.cs b/test/ReactiveExtensionsSharp.Tests/Extras/FromEventBufferedExtrasTests.cs similarity index 98% rename from test/RxSharp.Tests/Extras/FromEventBufferedExtrasTests.cs rename to test/ReactiveExtensionsSharp.Tests/Extras/FromEventBufferedExtrasTests.cs index 4ea679b..e156c4f 100644 --- a/test/RxSharp.Tests/Extras/FromEventBufferedExtrasTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Extras/FromEventBufferedExtrasTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Extras; +namespace ReactiveExtensionsSharp.Tests.Extras; [TestFixture] public class FromEventBufferedExtrasTests diff --git a/test/RxSharp.Tests/Extras/TimeoutExtrasTests.cs b/test/ReactiveExtensionsSharp.Tests/Extras/TimeoutExtrasTests.cs similarity index 93% rename from test/RxSharp.Tests/Extras/TimeoutExtrasTests.cs rename to test/ReactiveExtensionsSharp.Tests/Extras/TimeoutExtrasTests.cs index 28e0edb..2ddff21 100644 --- a/test/RxSharp.Tests/Extras/TimeoutExtrasTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Extras/TimeoutExtrasTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Extras; +namespace ReactiveExtensionsSharp.Tests.Extras; [TestFixture] public class TimeoutExtrasTests diff --git a/test/RxSharp.Tests/ForkJoinTests.cs b/test/ReactiveExtensionsSharp.Tests/ForkJoinTests.cs similarity index 98% rename from test/RxSharp.Tests/ForkJoinTests.cs rename to test/ReactiveExtensionsSharp.Tests/ForkJoinTests.cs index ea8305b..fdfa114 100644 --- a/test/RxSharp.Tests/ForkJoinTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/ForkJoinTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/forkJoin-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/MergeTests.cs b/test/ReactiveExtensionsSharp.Tests/MergeTests.cs similarity index 96% rename from test/RxSharp.Tests/MergeTests.cs rename to test/ReactiveExtensionsSharp.Tests/MergeTests.cs index 356bdf4..3acb5ff 100644 --- a/test/RxSharp.Tests/MergeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/MergeTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/merge-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Observable.CreationTests.cs b/test/ReactiveExtensionsSharp.Tests/Observable.CreationTests.cs similarity index 97% rename from test/RxSharp.Tests/Observable.CreationTests.cs rename to test/ReactiveExtensionsSharp.Tests/Observable.CreationTests.cs index 8ac1f44..d2b3e1a 100644 --- a/test/RxSharp.Tests/Observable.CreationTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Observable.CreationTests.cs @@ -1,7 +1,7 @@ using System.Globalization; -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; [TestFixture] public class ObservableCreationTests @@ -185,8 +185,8 @@ public void OnErrorResumeNext_ShouldNotAdvanceToTheNextSourceWhenExternallyUnsub [Test] public void Merge_ShouldEmitFromAllSourcesConcurrentlyAndCompleteWhenAllHaveCompleted() { - var subjectA = new RxSharp.Subjects.Subject(); - var subjectB = new RxSharp.Subjects.Subject(); + var subjectA = new ReactiveExtensionsSharp.Subjects.Subject(); + var subjectB = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var completed = false; @@ -235,8 +235,8 @@ public void Zip_ShouldCombinePositionallyAndCompleteWhenTheShortestSourceIsExhau [Test] public void ForkJoin_ShouldEmitTheLastValueOfEachSourceOnceAllHaveCompleted() { - var subjectA = new RxSharp.Subjects.Subject(); - var subjectB = new RxSharp.Subjects.Subject(); + var subjectA = new ReactiveExtensionsSharp.Subjects.Subject(); + var subjectB = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List>(); Observable.ForkJoin(subjectA.AsObservable(), subjectB.AsObservable()).Subscribe(results.Add); @@ -267,8 +267,8 @@ public void ForkJoin_ShouldCompleteWithoutEmittingIfAnySourceNeverEmitsAValue() [Test] public void CombineLatest_ShouldEmitOnEveryEmissionOnceAllSourcesHaveEmittedAtLeastOnce() { - var subjectA = new RxSharp.Subjects.Subject(); - var subjectB = new RxSharp.Subjects.Subject(); + var subjectA = new ReactiveExtensionsSharp.Subjects.Subject(); + var subjectB = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List>(); Observable.CombineLatest(subjectA.AsObservable().Map(x => (object)x), subjectB.AsObservable().Map(x => (object)x)) diff --git a/test/RxSharp.Tests/ObservableTests.cs b/test/ReactiveExtensionsSharp.Tests/ObservableTests.cs similarity index 97% rename from test/RxSharp.Tests/ObservableTests.cs rename to test/ReactiveExtensionsSharp.Tests/ObservableTests.cs index 79de66d..b5c4674 100644 --- a/test/RxSharp.Tests/ObservableTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/ObservableTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported from rxjs 7.8.2 spec/Observable-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/AuditTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/AuditTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/AuditTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/AuditTests.cs index 5d425b5..3bff49a 100644 --- a/test/RxSharp.Tests/Operators/AuditTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/AuditTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/audit-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/AuditTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/AuditTimeTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/AuditTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/AuditTimeTests.cs index b9c84f6..7c03b66 100644 --- a/test/RxSharp.Tests/Operators/AuditTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/AuditTimeTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/auditTime-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/BufferCountTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/BufferCountTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/BufferCountTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/BufferCountTests.cs index b0e3aaa..c5c3971 100644 --- a/test/RxSharp.Tests/Operators/BufferCountTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/BufferCountTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/bufferCount-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/BufferTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/BufferTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/BufferTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/BufferTests.cs index f39679e..ddd3bd9 100644 --- a/test/RxSharp.Tests/Operators/BufferTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/BufferTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/buffer-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/BufferTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/BufferTimeTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/BufferTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/BufferTimeTests.cs index 25ee6b1..a7c66eb 100644 --- a/test/RxSharp.Tests/Operators/BufferTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/BufferTimeTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/bufferTime-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/BufferWhenTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/BufferWhenTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/BufferWhenTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/BufferWhenTests.cs index 7394f81..fe6742e 100644 --- a/test/RxSharp.Tests/Operators/BufferWhenTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/BufferWhenTests.cs @@ -1,8 +1,8 @@ using System.Reflection; -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/bufferWhen-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/CatchErrorTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/CatchErrorTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/CatchErrorTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/CatchErrorTests.cs index cfc1dd7..c65678c 100644 --- a/test/RxSharp.Tests/Operators/CatchErrorTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/CatchErrorTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/catchError-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/CombineLatestAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestAllTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/CombineLatestAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestAllTests.cs index 8cbe93c..8fd4812 100644 --- a/test/RxSharp.Tests/Operators/CombineLatestAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestAllTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/combineLatestAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/CombineLatestWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestWithTests.cs similarity index 88% rename from test/RxSharp.Tests/Operators/CombineLatestWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestWithTests.cs index 7acade5..f83de6d 100644 --- a/test/RxSharp.Tests/Operators/CombineLatestWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/CombineLatestWithTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/combineLatestWith-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ConcatAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatAllTests.cs similarity index 92% rename from test/RxSharp.Tests/Operators/ConcatAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ConcatAllTests.cs index dcf1320..51bc716 100644 --- a/test/RxSharp.Tests/Operators/ConcatAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatAllTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/concatAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ConcatMapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/ConcatMapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapTests.cs index 03287d0..394d16e 100644 --- a/test/RxSharp.Tests/Operators/ConcatMapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/concatMap-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ConcatMapToTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapToTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/ConcatMapToTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapToTests.cs index 712c133..bfb3959 100644 --- a/test/RxSharp.Tests/Operators/ConcatMapToTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatMapToTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/concatMapTo-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ConcatWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatWithTests.cs similarity index 92% rename from test/RxSharp.Tests/Operators/ConcatWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ConcatWithTests.cs index 6f0a7e6..f67759d 100644 --- a/test/RxSharp.Tests/Operators/ConcatWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ConcatWithTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/concatWith-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/CountTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/CountTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/CountTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/CountTests.cs index ed53fde..d1dfee6 100644 --- a/test/RxSharp.Tests/Operators/CountTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/CountTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/count-spec.ts. [TestFixture] @@ -84,7 +84,7 @@ public void ShouldHandleAPredicateThatThrows() [Test] public void ShouldNotCompleteIfSourceNeverCompletes() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var completed = false; subject.AsObservable().Count().Subscribe(results.Add, onComplete: () => completed = true); diff --git a/test/RxSharp.Tests/Operators/DebounceTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DebounceTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/DebounceTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DebounceTests.cs index 0d4d53a..273c121 100644 --- a/test/RxSharp.Tests/Operators/DebounceTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DebounceTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/debounce-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DebounceTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DebounceTimeTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/DebounceTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DebounceTimeTests.cs index fa550a8..d7e2d33 100644 --- a/test/RxSharp.Tests/Operators/DebounceTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DebounceTimeTests.cs @@ -1,8 +1,8 @@ -using RxSharp.Operators; -using RxSharp.Subjects; -using RxSharp.Testing; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/debounceTime-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DefaultIfEmptyTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DefaultIfEmptyTests.cs similarity index 91% rename from test/RxSharp.Tests/Operators/DefaultIfEmptyTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DefaultIfEmptyTests.cs index 1b4d5e7..20dc5fa 100644 --- a/test/RxSharp.Tests/Operators/DefaultIfEmptyTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DefaultIfEmptyTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/defaultIfEmpty-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DelayTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DelayTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/DelayTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DelayTests.cs index a3766ab..856bd88 100644 --- a/test/RxSharp.Tests/Operators/DelayTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DelayTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Testing; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/delay-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DelayWhenTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DelayWhenTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/DelayWhenTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DelayWhenTests.cs index 6487d19..343909c 100644 --- a/test/RxSharp.Tests/Operators/DelayWhenTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DelayWhenTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/delayWhen-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DisposalCascadeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DisposalCascadeTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/DisposalCascadeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DisposalCascadeTests.cs index d7abe65..db40fb3 100644 --- a/test/RxSharp.Tests/Operators/DisposalCascadeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DisposalCascadeTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Regression tests for the SubscribeChild fix (see CLAUDE.md Learnings): an operator with a single, stable // inner subscription must register that inner subscriber as a child of its own downstream subscriber, so a diff --git a/test/RxSharp.Tests/Operators/DistinctTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/DistinctTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DistinctTests.cs index 05766dc..767ed97 100644 --- a/test/RxSharp.Tests/Operators/DistinctTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/distinct-spec.ts. [TestFixture] @@ -94,7 +94,7 @@ public void ShouldRaiseErrorWhenKeySelectorThrows() [Test] public void ShouldStopEmittingAfterExplicitUnsubscribe() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var subscription = subject.AsObservable().Distinct().Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/DistinctUntilChangedTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilChangedTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/DistinctUntilChangedTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilChangedTests.cs index cc570de..ea5dd2d 100644 --- a/test/RxSharp.Tests/Operators/DistinctUntilChangedTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilChangedTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/distinctUntilChanged-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs index 2bff535..7367b53 100644 --- a/test/RxSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/DistinctUntilKeyChangedTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/distinctUntilKeyChanged-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ElementAtTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ElementAtTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/ElementAtTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ElementAtTests.cs index 42ea9a8..3f9f134 100644 --- a/test/RxSharp.Tests/Operators/ElementAtTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ElementAtTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/elementAt-spec.ts. [TestFixture] @@ -81,7 +81,7 @@ public void ShouldPropagateErrorFromTheSourceObservable() [Test] public void ShouldUnsubscribeFromTheSourceWhenTheIndexIsReached() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().ElementAt(1).Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/EndWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/EndWithTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/EndWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/EndWithTests.cs index 64ccf45..644c475 100644 --- a/test/RxSharp.Tests/Operators/EndWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/EndWithTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/endWith-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/EveryTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/EveryTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/EveryTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/EveryTests.cs index 4d4c645..82ca551 100644 --- a/test/RxSharp.Tests/Operators/EveryTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/EveryTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/every-spec.ts. [TestFixture] @@ -97,7 +97,7 @@ public void ShouldPropagateErrorIfPredicateEventuallyThrows() [Test] public void ShouldUnsubscribeFromTheSourceAsSoonAsThePredicateFails() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().Every(Predicate).Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/ExhaustAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ExhaustAllTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/ExhaustAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ExhaustAllTests.cs index a26520b..ea2eb8e 100644 --- a/test/RxSharp.Tests/Operators/ExhaustAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ExhaustAllTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/exhaustAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ExhaustMapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ExhaustMapTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/ExhaustMapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ExhaustMapTests.cs index 3277425..7f00b1a 100644 --- a/test/RxSharp.Tests/Operators/ExhaustMapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ExhaustMapTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/exhaustMap-spec.ts. The deprecated resultSelector // overload is not ported (not part of this port's surface). diff --git a/test/RxSharp.Tests/Operators/ExpandTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ExpandTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/ExpandTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ExpandTests.cs index c9a94a5..81f4f6c 100644 --- a/test/RxSharp.Tests/Operators/ExpandTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ExpandTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/expand-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/FilterTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/FilterTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/FilterTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/FilterTests.cs index 63da132..3626204 100644 --- a/test/RxSharp.Tests/Operators/FilterTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/FilterTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/filter-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/FinalizeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/FinalizeTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/FinalizeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/FinalizeTests.cs index 3d4a5a2..532815f 100644 --- a/test/RxSharp.Tests/Operators/FinalizeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/FinalizeTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/finalize-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/FindIndexTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/FindIndexTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/FindIndexTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/FindIndexTests.cs index 78bd294..42cbf1f 100644 --- a/test/RxSharp.Tests/Operators/FindIndexTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/FindIndexTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/findIndex-spec.ts. [TestFixture] @@ -76,7 +76,7 @@ public void ShouldRaiseErrorIfPredicateThrows() [Test] public void ShouldUnsubscribeWhenThePredicateIsMatched() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().FindIndex(value => value == "b").Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/FindTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/FindTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/FindTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/FindTests.cs index 4e9ec2d..e9ccbce 100644 --- a/test/RxSharp.Tests/Operators/FindTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/FindTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/find-spec.ts. [TestFixture] @@ -76,7 +76,7 @@ public void ShouldRaiseErrorIfPredicateThrows() [Test] public void ShouldUnsubscribeWhenThePredicateIsMatched() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().Find(value => value == "b").Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/FirstTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/FirstTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/FirstTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/FirstTests.cs index 0acd65f..9550a12 100644 --- a/test/RxSharp.Tests/Operators/FirstTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/FirstTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/first-spec.ts (non-marble cases). [TestFixture] @@ -75,7 +75,7 @@ public void ShouldReturnTheDefaultValueWhenNoValueMatchesThePredicate() [Test] public void ShouldUnsubscribeWhenTheFirstValueIsReceived() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().First().Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/GroupByTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/GroupByTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/GroupByTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/GroupByTests.cs index 904e7e4..fec92ee 100644 --- a/test/RxSharp.Tests/Operators/GroupByTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/GroupByTests.cs @@ -1,11 +1,11 @@ using System.Reflection; -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/groupBy-spec.ts. The duration-selector tests are -// adapted (rxjs uses `skip(1)`/`skip(2)` on the group itself, which RxSharp does not implement yet) to instead +// adapted (rxjs uses `skip(1)`/`skip(2)` on the group itself, which ReactiveExtensionsSharp does not implement yet) to instead // use an externally controlled duration Subject that closes the group on demand. [TestFixture] public class GroupByTests diff --git a/test/RxSharp.Tests/Operators/IgnoreElementsTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/IgnoreElementsTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/IgnoreElementsTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/IgnoreElementsTests.cs index d7cfef4..f1f783d 100644 --- a/test/RxSharp.Tests/Operators/IgnoreElementsTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/IgnoreElementsTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/ignoreElements-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/IsEmptyTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/IsEmptyTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/IsEmptyTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/IsEmptyTests.cs index 5cc511d..6d77ad7 100644 --- a/test/RxSharp.Tests/Operators/IsEmptyTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/IsEmptyTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/isEmpty-spec.ts. [TestFixture] @@ -31,7 +31,7 @@ public void ShouldReturnFalseIfSourceEmitsElement() [Test] public void ShouldEmitFalseAsSoonAsTheFirstValueArrivesWithoutWaitingForCompletion() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().IsEmpty().Subscribe(results.Add); @@ -54,7 +54,7 @@ public void ShouldRaiseErrorIfSourceRaisesError() [Test] public void ShouldNotCompleteIfSourceNeverEmits() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var completed = false; subject.AsObservable().IsEmpty().Subscribe(results.Add, onComplete: () => completed = true); diff --git a/test/RxSharp.Tests/Operators/LastTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/LastTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/LastTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/LastTests.cs index 53f282f..bd7b035 100644 --- a/test/RxSharp.Tests/Operators/LastTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/LastTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/last-spec.ts (all cases there are marble-based; converted to // direct-value equivalents since timing is not the point being tested). @@ -103,7 +103,7 @@ public void ShouldPropagateErrorFromTheSourceObservable() [Test] public void ShouldUnsubscribeWhenTheSourceObservableIsUnsubscribedExplicitly() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var subscription = subject.AsObservable().Last().Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/MapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MapTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/MapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MapTests.cs index bd978bb..7d7716f 100644 --- a/test/RxSharp.Tests/Operators/MapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MapTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/map-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MapToTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MapToTests.cs similarity index 91% rename from test/RxSharp.Tests/Operators/MapToTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MapToTests.cs index 1967950..b680848 100644 --- a/test/RxSharp.Tests/Operators/MapToTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MapToTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mapTo-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MaterializeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MaterializeTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/MaterializeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MaterializeTests.cs index 1581096..e2a3173 100644 --- a/test/RxSharp.Tests/Operators/MaterializeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MaterializeTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/materialize-spec.ts (non-marble subset). Most of that spec file is // TestScheduler marble assertions; the essential behaviors they check (next/error/complete each become a diff --git a/test/RxSharp.Tests/Operators/MaxTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MaxTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/MaxTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MaxTests.cs index c4af81c..2febb38 100644 --- a/test/RxSharp.Tests/Operators/MaxTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MaxTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/max-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MergeAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MergeAllTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/MergeAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MergeAllTests.cs index 9551155..7f977c2 100644 --- a/test/RxSharp.Tests/Operators/MergeAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MergeAllTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mergeAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MergeMapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MergeMapTests.cs similarity index 91% rename from test/RxSharp.Tests/Operators/MergeMapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MergeMapTests.cs index 54e1e8d..3323b9e 100644 --- a/test/RxSharp.Tests/Operators/MergeMapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MergeMapTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mergeMap-spec.ts. [TestFixture] @@ -40,8 +40,8 @@ public void ShouldPropagateErrorsFromAnInnerObservable() [Test] public void ShouldOnlyCompleteWhenTheSourceAndAllInnersHaveCompleted() { - var subjectA = new RxSharp.Subjects.Subject(); - var subjectB = new RxSharp.Subjects.Subject(); + var subjectA = new ReactiveExtensionsSharp.Subjects.Subject(); + var subjectB = new ReactiveExtensionsSharp.Subjects.Subject(); var completed = false; Observable.Of(subjectA.AsObservable(), subjectB.AsObservable()) diff --git a/test/RxSharp.Tests/Operators/MergeMapToTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MergeMapToTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/MergeMapToTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MergeMapToTests.cs index abc3b55..22d1847 100644 --- a/test/RxSharp.Tests/Operators/MergeMapToTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MergeMapToTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mergeMapTo-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MergeScanTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MergeScanTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/MergeScanTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MergeScanTests.cs index 99a0c53..8bb241a 100644 --- a/test/RxSharp.Tests/Operators/MergeScanTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MergeScanTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mergeScan-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MergeWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MergeWithTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/MergeWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MergeWithTests.cs index 8a0984b..17fdc6c 100644 --- a/test/RxSharp.Tests/Operators/MergeWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MergeWithTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/mergeWith-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/MinTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/MinTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/MinTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/MinTests.cs index b442eeb..962a024 100644 --- a/test/RxSharp.Tests/Operators/MinTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/MinTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/min-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs index 39ae0b3..55ad9a1 100644 --- a/test/RxSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/OnErrorResumeNextOperatorTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/onErrorResumeNext-spec.ts, exercised via the // pipeable operator form (source.OnErrorResumeNext(...)). The standalone creation-function form diff --git a/test/RxSharp.Tests/Operators/PairwiseTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/PairwiseTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/PairwiseTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/PairwiseTests.cs index c6a3d62..3a9002a 100644 --- a/test/RxSharp.Tests/Operators/PairwiseTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/PairwiseTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/pairwise-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/PartitionTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/PartitionTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/PartitionTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/PartitionTests.cs index b718222..a55218f 100644 --- a/test/RxSharp.Tests/Operators/PartitionTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/PartitionTests.cs @@ -1,12 +1,12 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/partition-spec.ts. rxjs's own partition is // literally `[filter(predicate)(source), filter(not(predicate))(source)]` — two independent subscriptions to // the source, one per returned observable — confirmed against // src/internal/observable/partition.ts at the 7.8.2 tag. These tests port that behavior rather than the -// marble/expectSubscriptions assertions (no subscription-log helper exists yet in RxSharp.Testing), using +// marble/expectSubscriptions assertions (no subscription-log helper exists yet in ReactiveExtensionsSharp.Testing), using // plain result-list/subscription-count assertions instead, in the same style as FilterTests/GroupByTests. [TestFixture] public class PartitionTests @@ -126,7 +126,7 @@ public void ShouldPartitionIfThePredicateMatchesAllOfSourceElements() } // rxjs asserts this via `expectSubscriptions(e1.subscriptions).toBe([e1subs, e1subs])` — the source gets - // exactly two independent subscriptions, one per returned observable. RxSharp.Testing has no + // exactly two independent subscriptions, one per returned observable. ReactiveExtensionsSharp.Testing has no // subscription-log helper yet, so this counts subscriptions directly against a hand-rolled source instead. [Test] public void ShouldSubscribeToTheSourceExactlyOncePerReturnedObservable() diff --git a/test/RxSharp.Tests/Operators/RaceWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/RaceWithTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/RaceWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/RaceWithTests.cs index 9f8b2bd..b2487e5 100644 --- a/test/RxSharp.Tests/Operators/RaceWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/RaceWithTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/race-spec.ts, exercised via the raceWith // pipeable operator rather than the standalone Race creation function -- RaceWith backs the Puppeteer-essential diff --git a/test/RxSharp.Tests/Operators/ReduceTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ReduceTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/ReduceTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ReduceTests.cs index 1652787..8ffb00b 100644 --- a/test/RxSharp.Tests/Operators/ReduceTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ReduceTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/reduce-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/RepeatTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/RepeatTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/RepeatTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/RepeatTests.cs index 0d0052c..dd0c133 100644 --- a/test/RxSharp.Tests/Operators/RepeatTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/RepeatTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/repeat-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/RepeatWhenTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/RepeatWhenTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/RepeatWhenTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/RepeatWhenTests.cs index 4e7a89d..863bb49 100644 --- a/test/RxSharp.Tests/Operators/RepeatWhenTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/RepeatWhenTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/repeatWhen-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/RetryTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/RetryTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/RetryTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/RetryTests.cs index deb7c8b..a51b4c1 100644 --- a/test/RxSharp.Tests/Operators/RetryTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/RetryTests.cs @@ -1,8 +1,8 @@ -using RxSharp.Operators; -using RxSharp.Subjects; -using RxSharp.Testing; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/retry-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/RetryWhenTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/RetryWhenTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/RetryWhenTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/RetryWhenTests.cs index e53a3e4..04df8f1 100644 --- a/test/RxSharp.Tests/Operators/RetryWhenTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/RetryWhenTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/retryWhen-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SampleTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SampleTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/SampleTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SampleTests.cs index 7687f56..a13f119 100644 --- a/test/RxSharp.Tests/Operators/SampleTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SampleTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/sample-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SampleTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SampleTimeTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/SampleTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SampleTimeTests.cs index 8dee645..cbc3b2a 100644 --- a/test/RxSharp.Tests/Operators/SampleTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SampleTimeTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/sampleTime-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ScanTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ScanTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/ScanTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ScanTests.cs index 985f729..1a6220a 100644 --- a/test/RxSharp.Tests/Operators/ScanTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ScanTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/scan-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SequenceEqualTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SequenceEqualTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/SequenceEqualTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SequenceEqualTests.cs index 30c5d56..9bc91ce 100644 --- a/test/RxSharp.Tests/Operators/SequenceEqualTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SequenceEqualTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/sequenceEqual-spec.ts. [TestFixture] @@ -115,8 +115,8 @@ public void ShouldErrorIfTheComparerFunctionThrows() [Test] public void ShouldCompareValuesThatArriveInterleavedFromBothSides() { - var source = new RxSharp.Subjects.Subject(); - var other = new RxSharp.Subjects.Subject(); + var source = new ReactiveExtensionsSharp.Subjects.Subject(); + var other = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); source.AsObservable().SequenceEqual(other.AsObservable()).Subscribe(results.Add); diff --git a/test/RxSharp.Tests/Operators/ShareReplayTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ShareReplayTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/ShareReplayTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ShareReplayTests.cs index 0846758..4a8e356 100644 --- a/test/RxSharp.Tests/Operators/ShareReplayTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ShareReplayTests.cs @@ -1,10 +1,10 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/shareReplay-spec.ts (non-marble cases only -- the vast majority of that -// file is TestScheduler marble assertions, which RxSharp can't run yet with no virtual-time scheduler). The +// file is TestScheduler marble assertions, which ReactiveExtensionsSharp can't run yet with no virtual-time scheduler). The // multi-subscriber/replay marble cases are adapted here into an equivalent, non-marble form: a plain Subject // stands in for rxjs's "hot" marble source, driven manually instead of on a virtual timeline. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ShareTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ShareTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/ShareTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ShareTests.cs index 73747bf..41a2030 100644 --- a/test/RxSharp.Tests/Operators/ShareTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ShareTests.cs @@ -1,10 +1,10 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/share-spec.ts (non-marble cases only -- the vast majority of that file -// is TestScheduler marble assertions, which RxSharp can't run yet with no virtual-time scheduler). The +// is TestScheduler marble assertions, which ReactiveExtensionsSharp can't run yet with no virtual-time scheduler). The // multi-subscriber/multicast marble cases ("should share the same values to multiple observers", "should share // an error from the source to multiple observers") are adapted here into an equivalent, non-marble form: a plain // Subject stands in for rxjs's "hot" marble source, driven manually instead of on a virtual timeline. diff --git a/test/RxSharp.Tests/Operators/SingleTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SingleTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/SingleTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SingleTests.cs index 70a5ddd..83c3b8c 100644 --- a/test/RxSharp.Tests/Operators/SingleTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SingleTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/single-spec.ts (all cases there are marble-based; converted to // direct-value equivalents since timing is not the point being tested). diff --git a/test/RxSharp.Tests/Operators/SkipLastTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SkipLastTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/SkipLastTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SkipLastTests.cs index 09a4b45..27884d1 100644 --- a/test/RxSharp.Tests/Operators/SkipLastTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SkipLastTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/skipLast-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SkipTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SkipTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/SkipTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SkipTests.cs index 6104d73..917ef05 100644 --- a/test/RxSharp.Tests/Operators/SkipTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SkipTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/skip-spec.ts (non-marble cases; other marble cases converted to // direct-value equivalents where timing is not the point being tested). diff --git a/test/RxSharp.Tests/Operators/SkipUntilTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SkipUntilTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/SkipUntilTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SkipUntilTests.cs index ccc8c00..26caa1f 100644 --- a/test/RxSharp.Tests/Operators/SkipUntilTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SkipUntilTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/skipUntil-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SkipWhileTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SkipWhileTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/SkipWhileTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SkipWhileTests.cs index fb15b6c..daa811c 100644 --- a/test/RxSharp.Tests/Operators/SkipWhileTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SkipWhileTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/skipWhile-spec.ts (non-marble cases; other marble cases converted to // direct-value equivalents where timing is not the point being tested). diff --git a/test/RxSharp.Tests/Operators/StartWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/StartWithTests.cs similarity index 94% rename from test/RxSharp.Tests/Operators/StartWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/StartWithTests.cs index 4dc4695..71f88f9 100644 --- a/test/RxSharp.Tests/Operators/StartWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/StartWithTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/startWith-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SwitchAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchAllTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/SwitchAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SwitchAllTests.cs index 531afc5..5dd7d56 100644 --- a/test/RxSharp.Tests/Operators/SwitchAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchAllTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/switchAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SwitchMapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapTests.cs similarity index 95% rename from test/RxSharp.Tests/Operators/SwitchMapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapTests.cs index 3419960..a7a4244 100644 --- a/test/RxSharp.Tests/Operators/SwitchMapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/switchMap-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SwitchMapToTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapToTests.cs similarity index 92% rename from test/RxSharp.Tests/Operators/SwitchMapToTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapToTests.cs index 3cc0180..7b90bd5 100644 --- a/test/RxSharp.Tests/Operators/SwitchMapToTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchMapToTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/switchMapTo-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/SwitchScanTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchScanTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/SwitchScanTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/SwitchScanTests.cs index 27a65cb..749a14d 100644 --- a/test/RxSharp.Tests/Operators/SwitchScanTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/SwitchScanTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/switchScan-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/TakeLastTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TakeLastTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/TakeLastTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TakeLastTests.cs index 754dd36..cf96ea5 100644 --- a/test/RxSharp.Tests/Operators/TakeLastTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TakeLastTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/takeLast-spec.ts (all cases there are marble-based; converted to // direct-value equivalents since timing is not the point being tested). diff --git a/test/RxSharp.Tests/Operators/TakeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TakeTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/TakeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TakeTests.cs index 81c1316..fb4f190 100644 --- a/test/RxSharp.Tests/Operators/TakeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TakeTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/take-spec.ts (non-marble cases). [TestFixture] @@ -70,7 +70,7 @@ public void ShouldPropagateErrorFromTheSourceObservable() [Test] public void ShouldUnsubscribeFromTheSourceWhenItReachesTheLimit() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); subject.AsObservable().Take(2).Subscribe(results.Add); @@ -84,7 +84,7 @@ public void ShouldUnsubscribeFromTheSourceWhenItReachesTheLimit() [Test] public void ShouldCompleteWhenTheSourceIsReentrant() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var results = new List(); var reentrantCallCount = 0; diff --git a/test/RxSharp.Tests/Operators/TakeUntilTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TakeUntilTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/TakeUntilTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TakeUntilTests.cs index 6f6e7c9..76a0841 100644 --- a/test/RxSharp.Tests/Operators/TakeUntilTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TakeUntilTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/takeUntil-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/TakeWhileTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TakeWhileTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/TakeWhileTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TakeWhileTests.cs index 74a4314..80ebeba 100644 --- a/test/RxSharp.Tests/Operators/TakeWhileTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TakeWhileTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/takeWhile-spec.ts (non-marble cases; other marble cases converted to // direct-value equivalents where timing is not the point being tested). diff --git a/test/RxSharp.Tests/Operators/TapTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TapTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/TapTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TapTests.cs index e1702dc..0cf187d 100644 --- a/test/RxSharp.Tests/Operators/TapTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TapTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/tap-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ThrottleTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/ThrottleTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTests.cs index ca36c92..a65fe0b 100644 --- a/test/RxSharp.Tests/Operators/ThrottleTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/throttle-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ThrottleTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTimeTests.cs similarity index 96% rename from test/RxSharp.Tests/Operators/ThrottleTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTimeTests.cs index 60a8b1f..af17434 100644 --- a/test/RxSharp.Tests/Operators/ThrottleTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ThrottleTimeTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/throttleTime-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ThrowIfEmptyTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ThrowIfEmptyTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/ThrowIfEmptyTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ThrowIfEmptyTests.cs index 623dcf0..c56a0f8 100644 --- a/test/RxSharp.Tests/Operators/ThrowIfEmptyTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ThrowIfEmptyTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported from rxjs 7.8.2 spec/operators/throwIfEmpty-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Operators/TimeIntervalTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TimeIntervalTests.cs similarity index 90% rename from test/RxSharp.Tests/Operators/TimeIntervalTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TimeIntervalTests.cs index 929fcc6..e7124ad 100644 --- a/test/RxSharp.Tests/Operators/TimeIntervalTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TimeIntervalTests.cs @@ -1,8 +1,8 @@ -using RxSharp.Operators; -using RxSharp.Subjects; -using RxSharp.Testing; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/timeInterval-spec.ts, driven manually via a // TestScheduler's virtual clock (advanced between pushes into a Subject) rather than marble syntax, for diff --git a/test/RxSharp.Tests/Operators/TimestampTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/TimestampTests.cs similarity index 89% rename from test/RxSharp.Tests/Operators/TimestampTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/TimestampTests.cs index bd21b18..ed41d7f 100644 --- a/test/RxSharp.Tests/Operators/TimestampTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/TimestampTests.cs @@ -1,8 +1,8 @@ -using RxSharp.Operators; -using RxSharp.Subjects; -using RxSharp.Testing; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/timestamp-spec.ts, driven manually via a // TestScheduler's virtual clock rather than marble syntax. diff --git a/test/RxSharp.Tests/Operators/ToArrayTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ToArrayTests.cs similarity index 92% rename from test/RxSharp.Tests/Operators/ToArrayTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ToArrayTests.cs index 174c98d..be084bb 100644 --- a/test/RxSharp.Tests/Operators/ToArrayTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ToArrayTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/toArray-spec.ts. [TestFixture] @@ -41,7 +41,7 @@ public void ShouldWorkWithErrorWithoutEmittingAList() [Test] public void ShouldNotCompleteIfSourceNeverCompletes() { - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); var emitted = false; var completed = false; subject.AsObservable().ToArray().Subscribe(_ => emitted = true, onComplete: () => completed = true); diff --git a/test/RxSharp.Tests/Operators/WindowCountTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/WindowCountTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/WindowCountTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/WindowCountTests.cs index 37cd6bb..602ee8c 100644 --- a/test/RxSharp.Tests/Operators/WindowCountTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/WindowCountTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/windowCount-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/WindowTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/WindowTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/WindowTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/WindowTests.cs index 97dc4e2..ec0a607 100644 --- a/test/RxSharp.Tests/Operators/WindowTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/WindowTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/window-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/WindowTimeTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/WindowTimeTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/WindowTimeTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/WindowTimeTests.cs index 3389654..a9d822f 100644 --- a/test/RxSharp.Tests/Operators/WindowTimeTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/WindowTimeTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/windowTime-spec.ts. [TestFixture] @@ -11,7 +11,7 @@ public void ShouldEmitNonOverlappingWindowsGivenOnlyAWindowTimeSpan() { using var signal = new ManualResetEventSlim(); var windows = new List>(); - var source = new RxSharp.Subjects.Subject(); + var source = new ReactiveExtensionsSharp.Subjects.Subject(); source.AsObservable().WindowTime(TimeSpan.FromMilliseconds(30)).Subscribe(window => { @@ -44,7 +44,7 @@ public void ShouldEmitNonOverlappingWindowsGivenOnlyAWindowTimeSpan() public void ShouldCloseAWindowEarlyOnceMaxWindowSizeIsReached() { var windows = new List>(); - var source = new RxSharp.Subjects.Subject(); + var source = new ReactiveExtensionsSharp.Subjects.Subject(); source.AsObservable().WindowTime(TimeSpan.FromSeconds(5), maxWindowSize: 2).Subscribe(window => { @@ -126,7 +126,7 @@ public void ShouldSupportOverlappingWindowsViaACreationInterval() { using var signal = new ManualResetEventSlim(); var opened = 0; - var source = new RxSharp.Subjects.Subject(); + var source = new ReactiveExtensionsSharp.Subjects.Subject(); source.AsObservable().WindowTime(TimeSpan.FromMilliseconds(60), TimeSpan.FromMilliseconds(20)).Subscribe(_ => { diff --git a/test/RxSharp.Tests/Operators/WindowWhenTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/WindowWhenTests.cs similarity index 98% rename from test/RxSharp.Tests/Operators/WindowWhenTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/WindowWhenTests.cs index e40bebb..694106d 100644 --- a/test/RxSharp.Tests/Operators/WindowWhenTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/WindowWhenTests.cs @@ -1,8 +1,8 @@ using System.Reflection; -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/windowWhen-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/WithLatestFromTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/WithLatestFromTests.cs similarity index 97% rename from test/RxSharp.Tests/Operators/WithLatestFromTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/WithLatestFromTests.cs index 8bd4286..a721f53 100644 --- a/test/RxSharp.Tests/Operators/WithLatestFromTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/WithLatestFromTests.cs @@ -1,7 +1,7 @@ -using RxSharp.Operators; -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Operators; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/withLatestFrom-spec.ts. The interop-observable // tests (arrays/promises/lowercase-o observables as implicit ObservableInput) are not portable: this port has diff --git a/test/RxSharp.Tests/Operators/ZipAllTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ZipAllTests.cs similarity index 93% rename from test/RxSharp.Tests/Operators/ZipAllTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ZipAllTests.cs index 49b63db..205ef44 100644 --- a/test/RxSharp.Tests/Operators/ZipAllTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ZipAllTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/zipAll-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/Operators/ZipWithTests.cs b/test/ReactiveExtensionsSharp.Tests/Operators/ZipWithTests.cs similarity index 91% rename from test/RxSharp.Tests/Operators/ZipWithTests.cs rename to test/ReactiveExtensionsSharp.Tests/Operators/ZipWithTests.cs index be46165..276a196 100644 --- a/test/RxSharp.Tests/Operators/ZipWithTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Operators/ZipWithTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Operators; +namespace ReactiveExtensionsSharp.Tests.Operators; // Ported (non-marble subset) from rxjs 7.8.2 spec/operators/zipWith-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs b/test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs similarity index 95% rename from test/RxSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs rename to test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs index 1f0e42f..0bba473 100644 --- a/test/RxSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RaceWithSignalAndTimerTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.PuppeteerScenarios; +namespace ReactiveExtensionsSharp.Tests.PuppeteerScenarios; /// /// Modeled on how Puppeteer's Browser.waitForTarget/Page.waitForRequest-shaped methods race a @@ -95,7 +95,7 @@ public void ShouldDisableTheTimeoutForAZeroOrNegativeValue() using var signal = new ManualResetEventSlim(); var results = new List(); - var subject = new RxSharp.Subjects.Subject(); + var subject = new ReactiveExtensionsSharp.Subjects.Subject(); subject.AsObservable() .RaceWithSignalAndTimer(TimeSpan.Zero, CancellationToken.None) .Subscribe(results.Add, onComplete: signal.Set); diff --git a/test/RxSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs b/test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs similarity index 97% rename from test/RxSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs rename to test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs index 00dbbbe..c7430c2 100644 --- a/test/RxSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/PuppeteerScenarios/RetryAndRaceWithSignalAndTimerTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.PuppeteerScenarios; +namespace ReactiveExtensionsSharp.Tests.PuppeteerScenarios; /// /// Modeled directly on how Puppeteer's Locator actions (click/fill/hover/wait) compose diff --git a/test/RxSharp.Tests/RxSharp.Tests.csproj b/test/ReactiveExtensionsSharp.Tests/ReactiveExtensionsSharp.Tests.csproj similarity index 89% rename from test/RxSharp.Tests/RxSharp.Tests.csproj rename to test/ReactiveExtensionsSharp.Tests/ReactiveExtensionsSharp.Tests.csproj index 5940930..ed32507 100644 --- a/test/RxSharp.Tests/RxSharp.Tests.csproj +++ b/test/ReactiveExtensionsSharp.Tests/ReactiveExtensionsSharp.Tests.csproj @@ -23,7 +23,7 @@ - + diff --git a/test/RxSharp.Tests/RxConfigTests.cs b/test/ReactiveExtensionsSharp.Tests/RxConfigTests.cs similarity index 95% rename from test/RxSharp.Tests/RxConfigTests.cs rename to test/ReactiveExtensionsSharp.Tests/RxConfigTests.cs index c45776c..7974790 100644 --- a/test/RxSharp.Tests/RxConfigTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/RxConfigTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; [TestFixture] public class RxConfigTests diff --git a/test/RxSharp.Tests/Samples/PipeSample.cs b/test/ReactiveExtensionsSharp.Tests/Samples/PipeSample.cs similarity index 90% rename from test/RxSharp.Tests/Samples/PipeSample.cs rename to test/ReactiveExtensionsSharp.Tests/Samples/PipeSample.cs index f8ecf95..69675c5 100644 --- a/test/RxSharp.Tests/Samples/PipeSample.cs +++ b/test/ReactiveExtensionsSharp.Tests/Samples/PipeSample.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Samples; +namespace ReactiveExtensionsSharp.Tests.Samples; /// /// Not an NUnit test: a real, compiled source for the README's "pipe" example. Kept in sync with the README via diff --git a/test/RxSharp.Tests/Samples/QuickTasteSample.cs b/test/ReactiveExtensionsSharp.Tests/Samples/QuickTasteSample.cs similarity index 94% rename from test/RxSharp.Tests/Samples/QuickTasteSample.cs rename to test/ReactiveExtensionsSharp.Tests/Samples/QuickTasteSample.cs index 5f5e5d4..282a3c5 100644 --- a/test/RxSharp.Tests/Samples/QuickTasteSample.cs +++ b/test/ReactiveExtensionsSharp.Tests/Samples/QuickTasteSample.cs @@ -1,6 +1,6 @@ -using RxSharp.Operators; +using ReactiveExtensionsSharp.Operators; -namespace RxSharp.Tests.Samples; +namespace ReactiveExtensionsSharp.Tests.Samples; /// /// Not an NUnit test: a real, compiled source for the README's "Quick taste" example. Kept in sync with the diff --git a/test/RxSharp.Tests/Samples/RetryUntilTimeoutSample.cs b/test/ReactiveExtensionsSharp.Tests/Samples/RetryUntilTimeoutSample.cs similarity index 92% rename from test/RxSharp.Tests/Samples/RetryUntilTimeoutSample.cs rename to test/ReactiveExtensionsSharp.Tests/Samples/RetryUntilTimeoutSample.cs index bc0daf2..707e434 100644 --- a/test/RxSharp.Tests/Samples/RetryUntilTimeoutSample.cs +++ b/test/ReactiveExtensionsSharp.Tests/Samples/RetryUntilTimeoutSample.cs @@ -1,6 +1,6 @@ -using RxSharp.Extras; +using ReactiveExtensionsSharp.Extras; -namespace RxSharp.Tests.Samples; +namespace ReactiveExtensionsSharp.Tests.Samples; /// /// Not an NUnit test: a real, compiled source for the README's "retry until timeout" example — the exact diff --git a/test/RxSharp.Tests/Subjects/AsyncSubjectTests.cs b/test/ReactiveExtensionsSharp.Tests/Subjects/AsyncSubjectTests.cs similarity index 98% rename from test/RxSharp.Tests/Subjects/AsyncSubjectTests.cs rename to test/ReactiveExtensionsSharp.Tests/Subjects/AsyncSubjectTests.cs index 5772661..9304b04 100644 --- a/test/RxSharp.Tests/Subjects/AsyncSubjectTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Subjects/AsyncSubjectTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Subjects; +namespace ReactiveExtensionsSharp.Tests.Subjects; // Ported from rxjs 7.8.2 spec/subjects/AsyncSubject-spec.ts (the whole file -- none of it is marble-based). [TestFixture] diff --git a/test/RxSharp.Tests/Subjects/BehaviorSubjectTests.cs b/test/ReactiveExtensionsSharp.Tests/Subjects/BehaviorSubjectTests.cs similarity index 95% rename from test/RxSharp.Tests/Subjects/BehaviorSubjectTests.cs rename to test/ReactiveExtensionsSharp.Tests/Subjects/BehaviorSubjectTests.cs index 41c795a..501e8bc 100644 --- a/test/RxSharp.Tests/Subjects/BehaviorSubjectTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Subjects/BehaviorSubjectTests.cs @@ -1,10 +1,10 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Subjects; +namespace ReactiveExtensionsSharp.Tests.Subjects; // Ported from rxjs 7.8.2 spec/subjects/BehaviorSubject-spec.ts (non-marble cases). // Deliberate divergence: rxjs throws ObjectUnsubscribedError when getValue() is called after the subject has -// been unsubscribed; RxSharp has no such distinct exception type (see SubjectTests.cs), so a disposed +// been unsubscribed; ReactiveExtensionsSharp has no such distinct exception type (see SubjectTests.cs), so a disposed // BehaviorSubject throws the ordinary ObjectDisposedException instead -- same pattern Subject itself // already uses for CheckDisposed(). [TestFixture] diff --git a/test/RxSharp.Tests/Subjects/ReplaySubjectTests.cs b/test/ReactiveExtensionsSharp.Tests/Subjects/ReplaySubjectTests.cs similarity index 97% rename from test/RxSharp.Tests/Subjects/ReplaySubjectTests.cs rename to test/ReactiveExtensionsSharp.Tests/Subjects/ReplaySubjectTests.cs index 552b792..ce22c87 100644 --- a/test/RxSharp.Tests/Subjects/ReplaySubjectTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Subjects/ReplaySubjectTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Subjects; +namespace ReactiveExtensionsSharp.Tests.Subjects; // Ported from rxjs 7.8.2 spec/subjects/ReplaySubject-spec.ts (non-marble cases). [TestFixture] diff --git a/test/RxSharp.Tests/Subjects/SubjectTests.cs b/test/ReactiveExtensionsSharp.Tests/Subjects/SubjectTests.cs similarity index 95% rename from test/RxSharp.Tests/Subjects/SubjectTests.cs rename to test/ReactiveExtensionsSharp.Tests/Subjects/SubjectTests.cs index 9978537..e0778d0 100644 --- a/test/RxSharp.Tests/Subjects/SubjectTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Subjects/SubjectTests.cs @@ -1,10 +1,10 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests.Subjects; +namespace ReactiveExtensionsSharp.Tests.Subjects; // Ported from rxjs 7.8.2 spec/Subject-spec.ts (non-marble cases). // Deliberate divergence: rxjs throws ObjectUnsubscribedError on next/error/complete after -// unsubscribe; RxSharp's Subject silently ignores instead (matching Subscriber's own +// unsubscribe; ReactiveExtensionsSharp's Subject silently ignores instead (matching Subscriber's own // isStopped/IsDisposed guard semantics) rather than introducing a distinct exception type // for it. See CLAUDE.md learnings. [TestFixture] diff --git a/test/RxSharp.Tests/SubscriberTests.cs b/test/ReactiveExtensionsSharp.Tests/SubscriberTests.cs similarity index 98% rename from test/RxSharp.Tests/SubscriberTests.cs rename to test/ReactiveExtensionsSharp.Tests/SubscriberTests.cs index 4fee223..a0b3d8c 100644 --- a/test/RxSharp.Tests/SubscriberTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/SubscriberTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported from rxjs 7.8.2 spec/Subscriber-spec.ts (SafeSubscriber describe block). [TestFixture] diff --git a/test/RxSharp.Tests/SubscriptionTests.cs b/test/ReactiveExtensionsSharp.Tests/SubscriptionTests.cs similarity index 98% rename from test/RxSharp.Tests/SubscriptionTests.cs rename to test/ReactiveExtensionsSharp.Tests/SubscriptionTests.cs index f4a674a..9843327 100644 --- a/test/RxSharp.Tests/SubscriptionTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/SubscriptionTests.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported from rxjs 7.8.2 spec/Subscription-spec.ts. [TestFixture] diff --git a/test/RxSharp.Tests/TestObserver.cs b/test/ReactiveExtensionsSharp.Tests/TestObserver.cs similarity index 92% rename from test/RxSharp.Tests/TestObserver.cs rename to test/ReactiveExtensionsSharp.Tests/TestObserver.cs index 8ee592b..0350516 100644 --- a/test/RxSharp.Tests/TestObserver.cs +++ b/test/ReactiveExtensionsSharp.Tests/TestObserver.cs @@ -1,4 +1,4 @@ -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; /// Collects emissions from a subscription for assertions. The NUnit-side equivalent of hand-rolled observers used throughout the rxjs spec suite. internal sealed class TestObserver : IObserver diff --git a/test/RxSharp.Tests/Testing/TestSchedulerTests.cs b/test/ReactiveExtensionsSharp.Tests/Testing/TestSchedulerTests.cs similarity index 98% rename from test/RxSharp.Tests/Testing/TestSchedulerTests.cs rename to test/ReactiveExtensionsSharp.Tests/Testing/TestSchedulerTests.cs index de64318..945b032 100644 --- a/test/RxSharp.Tests/Testing/TestSchedulerTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Testing/TestSchedulerTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Testing; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Testing; +namespace ReactiveExtensionsSharp.Tests.Testing; // No upstream rxjs spec equivalent — written from scratch to cover marble-string parsing and the cold/hot // observables built from it, end to end against the virtual clock. diff --git a/test/RxSharp.Tests/Testing/VirtualTimeSchedulerTests.cs b/test/ReactiveExtensionsSharp.Tests/Testing/VirtualTimeSchedulerTests.cs similarity index 98% rename from test/RxSharp.Tests/Testing/VirtualTimeSchedulerTests.cs rename to test/ReactiveExtensionsSharp.Tests/Testing/VirtualTimeSchedulerTests.cs index f871b1b..eac2686 100644 --- a/test/RxSharp.Tests/Testing/VirtualTimeSchedulerTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/Testing/VirtualTimeSchedulerTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Testing; +using ReactiveExtensionsSharp.Testing; -namespace RxSharp.Tests.Testing; +namespace ReactiveExtensionsSharp.Tests.Testing; // No upstream rxjs spec equivalent — marble-testing-the-marble-tester isn't a thing rxjs itself ports from. // Written from scratch to pin down the virtual-time queue's correctness guarantees: ordering, no missed/duplicate diff --git a/test/RxSharp.Tests/ZipTests.cs b/test/ReactiveExtensionsSharp.Tests/ZipTests.cs similarity index 98% rename from test/RxSharp.Tests/ZipTests.cs rename to test/ReactiveExtensionsSharp.Tests/ZipTests.cs index 15f1869..10dee14 100644 --- a/test/RxSharp.Tests/ZipTests.cs +++ b/test/ReactiveExtensionsSharp.Tests/ZipTests.cs @@ -1,6 +1,6 @@ -using RxSharp.Subjects; +using ReactiveExtensionsSharp.Subjects; -namespace RxSharp.Tests; +namespace ReactiveExtensionsSharp.Tests; // Ported (non-marble subset) from rxjs 7.8.2 spec/observables/zip-spec.ts. [TestFixture]