Storing AttributedString

You generally have the right approach here, but with a few small details missing leading to the confusion you're seeing.

First, on your custom attribute: the attribute is defined correctly. However, AttributedString conforms to Codable, but this default encoding implementation will only encode attributes defined in the SDK (as a convenience for use cases where you have no custom attributes). By calling JSONEncoder().encode(attrStr), you are using AttributedString's Codable implementation which only encodes SDK attributes and not your custom attribute. To encode custom attributes, you need to provide your custom attribute scope at encoding/decoding time using CodableWithConfiguration. You can do this by storing your AttributedString with custom attributes in a Codable struct and providing the scope in one of two ways:

Option 1: The @CodableConfiguration Property Wrapper

struct MyModel : Codable {
    @CodableConfiguration(from: \.myApp) var attrStr: AttributedString = AttributedString()
}

let model = MyModel(attrStr: attrStr)
let json = try JSONEncoder().encode(model)

Option 2: A custom encode implementation:

struct MyModel : Codable {
    var attrStr: AttributedString = AttributedString()

    // ... coding keys, decode function, etc.

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: MyCodingKey.self)
        container.encode(attrStr, forKey: .attrStrKey, configuration: AttributeScopes.MyAppAttributes.self)
    }
}

let model = MyModel(attrStr: attrStr)
let json = try JSONEncoder().encode(model)

Providing your scope via the @CodableConfiguration property wrapper or the configuration: parameter of the encode function provides AttributedString with the necessary information to encode your custom attributes.

Next, the SwiftUI attributes: you are correct that these attributes are not currently Codable. SwiftUI.Color and SwiftUI.Font are not Codable, however that is not the only reason why these attributes are not encoded when encoding an attributed string. In order for an attribute to be encoded, the AttributedStringKey-conforming type needs to conform to CodableAttributedStringKey (and AttributeScopes.SwiftUIAttributes.ForegroundColorAttribute and AttributeScopes.SwiftUIAttributes.FontAttribute do not conform to CodableAttributedStringKey because they are not currently designed to be encoded). So that is why even making Color and Font Codable would not cause the attributes to be encoded.

Thanks for the fast answer, but I think I'm still missing something.

I now created my own struct like this:

struct MyModel: Codable, Hashable {
    @CodableConfiguration(from: \.myApp) var attrStr: AttributedString = AttributedString()
}

And continued with:

enum MyModelTextAttribute: CodableAttributedStringKey {
    typealias Value = MyModel
    static let name = "myModelTextAttribute"
}

extension AttributeScopes {
    struct MyAppAttributes: AttributeScope {
        let myModelTextAttribute: MyModelTextAttribute

        let swiftUI: SwiftUIAttributes
    }
    var myApp: MyAppAttributes.Type { MyAppAttributes.self }
}

extension AttributeDynamicLookup {
    subscript<T: AttributedStringKey>(dynamicMember keyPath: KeyPath<AttributeScopes.MyAppAttributes, T>) -> T { self[T.self] }
}

The JSON decoding of the model works fine:

let model = MyModel(attrStr: AttributedString("Hi"))
let json = try JSONEncoder().encode(model)
print(String(data: json, encoding: .utf8) ?? "no data")
// prints: {"attrStr":"Hi"}

So I created an attributed string and set the attributes:

var attStr = AttributedString("Hello, here is some text.")
let range1 = attStr.range(of: "Hello")!
let range2 = attStr.range(of: "text")!
attStr[range1].myModelTextAttribute = model
attStr[range2].foregroundColor = .blue

Printing the attributed string with print(attStr) looks also fine:

Hello {
	myModelTextAttribute = MyModel(_attrStr: Foundation.CodableConfiguration<Foundation.AttributedString, (extension in __lldb_expr_87):Foundation.AttributeScopes.MyAppAttributes>(wrappedValue: Hi {
}))
}
, here is some  {
}
text {
	SwiftUI.ForegroundColor = blue
}
. {
}

But if I now try to convert it to JSON, my custom attribute is missing:

let jsonData = try JSONEncoder().encode(attStr)
print(String(data: jsonData, encoding: .utf8) ?? "no data")
// prints: ["Hello",{},", here is some ",{},"text",{"SwiftUI.ForegroundColor":{}},".",{}]

I also tried option 2 with a custom encode function in MyModel instead, but got the same result. Here is also my implementation for that:

struct MyModel: Codable, Hashable {
    var attrStr: AttributedString = AttributedString()

    enum MyCodingKey: CodingKey {
        case attrStrKey
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: MyCodingKey.self)
        try container.encode(attrStr, forKey: .attrStrKey, configuration: AttributeScopes.MyAppAttributes.self)
    }
}

I see now what I did wrong. I need to JSON encode the wrapper struct which holds the attributed string, so this can then use my custom attributes.

Here is my complete example. Maybe it also helps someone else:

import SwiftUI

extension AttributeScopes {
    var myApp: MyAppAttributes.Type { MyAppAttributes.self }

    struct MyAppAttributes: AttributeScope {
        let alternativeGreeting: AlternativeGreetingTextAttribute

        let swiftUI: SwiftUIAttributes
    }
}

extension AttributeDynamicLookup {
    subscript<T: AttributedStringKey>(dynamicMember keyPath: KeyPath<AttributeScopes.MyAppAttributes, T>) -> T { self[T.self] }
}

extension AttributeScopes.MyAppAttributes {
    enum AlternativeGreetingTextAttribute: CodableAttributedStringKey {
        typealias Value = String
        static let name = "alternativeGreeting"
    }
}

// Wrapper struct to also encode custom attributes
struct CodableType: Codable {
    @CodableConfiguration(from: \.myApp)
    var attrStr = AttributedString()
}

var attStr = AttributedString("Hello Max.")
attStr[attStr.range(of: "Hello")!].alternativeGreeting = "Hi"
attStr[attStr.range(of: "Max")!].personNameComponent = .givenName


// Decode to JSON, but use wrapper struct to recognize custom attributes
let jsonData = try JSONEncoder().encode(CodableType(attrStr: attStr))
print(String(data: jsonData, encoding: .utf8) ?? "no data")

print("-------")

// From JSON back to AttributedString
print(try JSONDecoder().decode(CodableType.self, from: jsonData).attrStr)