Update to Avalonia v11.3.9 and Implement ResourceDictionary DSL

[SilkyFowl]

This PR updates Avalonia from v11.1.0 to v11.3.9. With this version update, ResourceDictionary now inherits from AvaloniaObject, enabling us to implement ResourceDictionary-related DSL bindings.

Changes

Avalonia Version Update

• Updated Avalonia from v11.1.0 to v11.3.9 (Directory.Build.props)

ResourceDictionary DSL Implementation

New file: ResourceDictionary.fs

• ResourceDictionary.keyValue: Supports setting key-value pairs
  • Provides overloads for both object values (obj) and IView values
  • Implements clear functionality using ClearValue type
• ResourceDictionary.mergedDictionaries: Supports merged dictionaries
• ResourceDictionary.themeDictionariesKeyValue: Supports theme variant-specific resource dictionaries

ResourceInclude Wrapper Implementation

Since ResourceInclude does not inherit from AvaloniaObject, we implemented a ResourceIncludeWrapper class:

• Wraps ResourceInclude with a class that inherits from ResourceProvider
• Recreates the internal instance when the Source property changes to ensure resource updates
• Provides helper functions: fromUri, fromString

ResourceProvider DSL Implementation

New file: ResourceProvider.fs

• onResourceObservable: Binding that subscribes to GetResourceObservable
  • Supports optional defaultThemeVariant parameter
  • Wraps results in option type (treating null and UnsetValue as None)

StyledElement DSL Extensions

StyledElement.fs

• StyledElement.resources: Added overload that accepts IView
• StyledElement.onResourceObservable: Resource observation binding for StyledElement

Test Infrastructure Improvements

• Introduced Avalonia.Headless.XUnit package: Required for testing ResourceInclude
• Added ResourceDictionaryTests.fs: Comprehensive test suite (493 lines)
• Added TestHelpers.fs: Assertion helpers for tests
• Updated existing tests: Significantly expanded resource-related tests in StyledElementTests.fs
• Added test resource files: TestResources1.xaml, TestResources2.xaml

Minor Fixes

• AttrBuilder.fs: Fixed typos in documentation comments
• Types.fs, VirtualDom.Delta.fs, VirtualDom.Patcher.fs: Fixed typos in documentation comments

Implementation Details and Future Improvements

Dictionary-Type Property Implementation

Dictionary-type properties such as ResourceDictionary.keyValue and themeDictionariesKeyValue are currently implemented using AttrBuilder<'t>.CreateContentSingle. While this approach is unconventional, it has the beneficial side effect of allowing Views and raw values to be seamlessly mixed.

Current Implementation (Works)

StyledElement.create [
  StyledElement.resources (
    ResourceDictionary.create [
      ResourceDictionary.keyValue ("key1", "value1")
      ResourceDictionary.keyValue ("key2", 42)
      ResourceDictionary.keyValue ("key3", TextBlock.create [ TextBlock.text "text" ])
    ]
  )
]

Potential Future Improvement

If we were to provide a more explicit and type-safe API, it might look like this:

type KeyValueItem =
  | KeyValue of key:obj * valueObj:obj
  | KeyView of key:obj * valueView:IView

[<AbstractClass; Sealed>]
type AttrBuilder<'view> =
    new unit -> AttrBuilder<'view>
    static member CreateDictionaryProperty:
      name: string *
      getter: ('view -> obj) voption *
      setter: ('view * obj -> unit) voption *
      dictionaryProperty: KeyValueItem list
              -> IAttr<'view>

    static member CreateContentDictionary:
        name: string *
        getter: ('view -> obj) voption *
        setter: ('view * obj -> unit) voption *
        dictionaryContent: KeyValueItem list
            -> IAttr<'view>

Usage example with this API:

StyledElement.create [
  StyledElement.resources (
    ResourceDictionary.create [
      ResourceDictionary.keyValues [
        KeyValue("key1", "value1")
        KeyValue("key2", 42)
        KeyView("key3", TextBlock.create [ TextBlock.text "text" ])
      ]
    ]
  )
]

However, this change would require a significant update to the DSL API. If we decide to pursue this approach, it should be handled in a separate issue and pull request.

[JaggerJo]

@SilkyFowl wow, nice work!

Would be interesting to see how / what you use this for in your apps. Mainly for defining theme resources in F# I assume?

[SilkyFowl]

@JaggerJo Thank you for the review!

Yes, the primary use case is defining theme resources in F# without XAML. I plan to add a sample project to the Examples folder demonstrating these features.

Long-term Vision

Long-term, I want to achieve DSL-ification of the App class. To accomplish this, I recognize that we need to solve the #86 issue.

Challenges and Potential Solutions

• The Style class inherits from AvaloniaObject, which is good
• However, classes like Setter that don't inherit from AvaloniaObject will be obstacles
• Since IView's constraint has been relaxed from Control to AvaloniaObject, we might be able to handle this by creating wrapper classes (similar to ResourceIncludeWrapper) for types like StyleIncludeWrapper

I'll create a separate issue to discuss these long-term goals in more detail.

[Numpsy]

Sounds interesting, I'll have a look at the changes tommorow