Get attribute value with key

func value(_ key: String) -> String?

This would make finding an attribute value very compact and convenient

Add [Tag] to children with TagBuilder parameter

public func insert(at i: Int? = nil, if condition: Bool = true, @TagBuilder children: () -> [Tag]) -> Self
public func append(_ condition: Bool = true, @TagBuilder children: () -> [Tag]) -> Self

One more option when declaring a Tag. Right now it's either Tag(...) or Tag {...} This way is both Tag(...).insert{...}

Also, it would allow you to write func() calls on a Tag before declaring children. For example, instead of...

Div {
     // ... a huge hierarchy making me lose track of parent's closing bracket
}
.func()
.anotherFunc()
.anotherFunc()

You could put the func() calls next to the tag declaration. And then attributes are listed closer to the parent.

Div()
     .func()
     .anotherFunc()
     .anotherFunc()
     .append {
          // ... a huge hierarchy that seems better placed in code
     }

• Remove children at index

public func remove(at i: Int, if condition: Bool = true) -> Self

If children can be added, it seems only natural to also remove

Add type safety for making Attributes with...

enum AttributeKey: String {...}

Also, I added a function to the previous pull request for getting values with AttributeKey. Since it relies on that one being approved.

func value(_ key: AttributeKey) -> String? {
    self.value(key.rawValue)
}

Just a thought...

I tried using Tag with generics.

Got this compiler error...

Constructing an object of class type ’T’ with a metatype value must use a ‘required’ initializer

Example:

public class MyClass<T: Tag> {

let props: MyProps
let children: [Tag]

init(_ props: MyProps, @TagBuilder _ children: () -> [Tag]) {
    self.props = props
    self.children = children()
}

public func build() -> Tag {
    T(children)
        .doSomething(props)
        .anotherThing(props)
}

}

This proposal is predicated on the idea that space separated values inside the class attribute should be unique.

<p class='valueA valueB valueC'>...<\p>

I have been running into situations where I build complex objects on top of simpler ones. And many times I can't be sure if the simple object has certain values already set. So there are two choices—check the simple object for that value before adding, or just add the one I need.

Checking takes extra time and code for every string, like an unnecessary two-step process.

And blindly adding introduces the possibility of duplicate values, which, depending on the number of them, can lead to very messy html.

And just fundamentally, if class values should be unique, they should be managed that way.

Instead of...

func `class`(add value: String?, _ condition: Bool = true) -> Self

How about...

func `class`(insert value: String?, _ condition: Bool = true) -> Self

And then treat the underlying String like a Set while manipulating it.

So when you want to add a value, you don't have to worry about whether it exists or not. And no duplications. Changing the parameter label to insert reinforces that notion.

Also, I added a version that takes variadic Optionals.

func `class`(insert values: String?..., if condition: Bool = true) -> Self

I use it in my own code and find it extremely flexible. You can write...

tag.class(insert: v)
tag.class(insert: optionalV)

tag.class(insert: v, if: condition)
tag.class(insert: optionalV, if: condition)

tag.class(insert: v, optionalV)

tag.class(insert: v, optionalV, if: condition)

tag.class(insert: v, optionalV, "anything", if: condition)

The only rub is having to put a parameter label where there was none. I chose if to indicate the logic.

I won't take it personally if this seems a bit too far out on a limb. But it's really flexible and terse when you need to constantly add a few values here or there without the [ ]. And it keeps with the theme of every other function that accepts an optional value and a Bool condition.

I also changed...

func `class`(insert values: [String], _ condition: Bool = true) -> Self

...to take an optional array. Again more flexibility and keeps with the theme of every other func. But I understand if it's a bridge too far.

func `class`(insert values: [String]?, _ condition: Bool = true) -> Self

Lastly, I added a guard condition in...

func `class`(remove values: [String], _ condition: Bool = true) -> Self

I could be wrong, but I think the class attribute can be deleted even if the condition is false

I commented on my lines of code as well. Hopefully that makes things more clear.

Is there a reason the required init can't take both contents: String? and children: [Tag]?

So typography tags can be more readable?

For example:

<H4>Some text before a <span>styled text</span> and more after</H4>

Could be written...

H4("Some text before a") { Span("styled text") Text("and more after") }

When using libraries like Bootstrap, I often need to put child elements inside buttons. But the init() only takes contents.

Not sure if it was intentional. To only allow users to create Buttons with String contents. But I would think all Tags should have a designated init() that allows for children with a builder parameter, whether or not it produces well written HTML. And then the convenience inits would implement preferred or common usage. Like in A.swift where the convenience init() just takes contents.

Textarea bug: attribute value for disabled should be "disabled" and not "autofocus"

Tibor, this is the first time ever that I make a code change in Github. I hope, I do it correctly. Please check. Thx

These changes are primarily about trying to guarantee the format of the class attribute value is always consistent. And without empty or duplicate substrings. Regardless of whether it is set as a string literal in .attribute(...) or via the class(...) functions. And the best way to accomplish this is by treating the underlying attribute value like a Set rather than an Array

As an added benefit, the class attribute can handle .union(...), .subtraction(...) and .intersection(...) This is especially helpful when trying to eliminate lots of possible classes without having to interrogate for each one. It takes very little code to create a large Set and just subtract it.

<td> also has a colspan attribute.
reference: https://www.w3schools.com/tags/att_td_colspan.asp
I copied the function from <th>
and added a test for table with attributes.

• Get attribute value with key func value(_ key: String) -> String?

 This would make finding an attribute value very compact and convenient

• Add [Tag] to children with TagBuilder parameter public func insert(at i: Int? = nil, if condition: Bool = true, @TagBuilder children: () -> [Tag]) -> Self

 One more option when declaring a Tag. Right now it's either Tag(...) or Tag {...} This way is both Tag(...).insert{...}

 Also, it would allow you to write func() calls on a Tag before declaring children. For example, instead of...
      `Div {
            ... a huge hierarchy making me lose track of parent's closing bracket
       }
       .func()
       .anotherFunc()
       .anotherFunc()`

 You could put the func() calls next to the tag declaration. And then attributes are listed closer to the parent.
      `Div()
       .func()
       .anotherFunc()
       .anotherFunc()
       .insert {
               ... a huge hierarchy that seems better placed in code
       }`

• Remove children at index public func remove(at i: Int, if condition: Bool = true) -> Self

 If children can be added, it seems only natural to also remove

Eliminate empty strings from array before joining. Otherwise the final value may contain extra spaces.

let strings = ["1", "", "2", "3", ""]

let str = strings.joined(separator: " ") // => "1 23 "

let str2 = strings.filter{$0.count > 0}.joined(separator: " ") // => "123"