Compare Declarative Frameworks

struct MyComponent: View {
    var displayString: String
    var body: some View {
        Text(displayString)
    }
}

function MyComponent(props) {
  return <div>{props.displayString}</div>;
}

class MyComponent extends StatelessWidget {
  final String displayString;

  MyComponent({required this.displayString});

  @override
  Widget build(BuildContext context) {
    return Text(displayString);
  }
}

struct Parent: View {
    let data: String

    var body: some View {
        IntermediateComponent(data: data)
    }
}

struct IntermediateComponent: View {
    let data: String

    var body: some View {
        ChildComponent(data: data)
    }
}

struct ChildComponent: View {
    let data: String

    var body: some View {
        Text("Received data: \(data)")
    }
}

// Usage
Parent(data: "Some data")

function Parent({ data }) {
  return <IntermediateComponent data={data} />;
}

function IntermediateComponent({ data }) {
  return <ChildComponent data={data} />;
}

function ChildComponent({ data }) {
  return <p>Received data: {data}</p>;
}

// Usage
<Parent data="Some data" />;

class Parent extends StatelessWidget {
  final String data;

  Parent({required this.data});

  @override
  Widget build(BuildContext context) {
    return IntermediateComponent(data: data);
  }
}

class IntermediateComponent extends StatelessWidget {
  final String data;

  IntermediateComponent({required this.data});

  @override
  Widget build(BuildContext context) {
    return ChildComponent(data: data);
  }
}

class ChildComponent extends StatelessWidget {
  final String data;

  ChildComponent({required this.data});

  @override
  Widget build(BuildContext context) {
    return Text("Received data: $data");
  }
}

// Usage
Parent(data: "Some data")

struct TextInputComponent: View {
    @State private var text = ""

    var body: some View {
        TextField("Enter text", text: $text)
    }
}

function TextInputComponent() {
  const [text, setText] = useState("");

  return (
    <input
      type="text"
      value={text}
      onChange={(e) => setText(e.target.value)}
      placeholder="Enter text"
    />
  );
}

class TextInputComponent extends StatefulWidget {
  const TextInputComponent({super.key});

  @override
  State<TextInputComponent> createState() => _TextInputComponentState();
}

class _TextInputComponentState extends State<TextInputComponent> {
  late final _controller = TextEditingController(text: "");

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return TextField(
      controller: _controller,
      decoration: const InputDecoration(labelText: "Enter text"),
    );
  }
}

struct ListComponent: View {
    let items: [String]

    var body: some View {
        List(items, id: \.self) { item in
            Text(item)
        }
    }
}

// Usage
let items = ["Item 1", "Item 2", "Item 3"]
ListComponent(items: items)

function ListComponent({ items }) {
  return (
    <ul>
      {items.map((item) => (
        <li key={item}>{item}</li>
      ))}
    </ul>
  );
}

// Usage
const items = ["Item 1", "Item 2", "Item 3"];
<ListComponent items={items} />;

class ListComponent extends StatelessWidget {
  final List<String> items;

  ListComponent({required this.items});

  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: items.length,
      itemBuilder: (context, index) {
        return ListTile(title: Text(items[index]));
      },
    );
  }
}

// Usage
final items = ["Item 1", "Item 2", "Item 3"];
ListComponent(items: items)

struct Parent<Header: View, Content: View>: View {
    let header: Header
    let content: Content

    var body: some View {
        VStack {
            header
            content
        }
    }
}

// Usage
Parent(
    header: Text("Header"),
    content: Child()
)

struct Child: View {
    var body: some View {
        Text("Child Content")
    }
}

function Parent({ header, content }) {
  return (
    <div>
      {header}
      {content}
    </div>
  );
}

// Usage
<Parent header={<h1>Header</h1>} content={<Child />} />;

function Child() {
  return <p>Child Content</p>;
}

class Parent extends StatelessWidget {
  final Widget header;
  final Widget content;

  Parent({required this.header, required this.content});

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        header,
        content,
      ],
    );
  }
}

// Usage
Parent(
  header: Text("Header"),
  content: Child(),
)

class Child extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Text("Child Content");
  }
}

struct Counter: View {
    @State private var count = 0

    var body: some View {
        Button(action: {
            count += 1
        }) {
            Text("Count: \(count)")
        }
    }
}

import { useState } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <button onClick={() => setCount(count + 1)}>
        Count: {count}
    </button>
  );
}

class Counter extends StatefulWidget {
  @override
  _CounterState createState() => _CounterState();
}

class _CounterState extends State<Counter> {
  int count = 0;

  @override
  Widget build(BuildContext context) {
    return RaisedButton(
      onPressed: () => setState(() => count += 1),
      child: Text("Count: $count"),
    );
  }
}

struct SideEffectOnLoadComponent: View {
    @State private var hasPerformedSideEffect = false

    var body: some View {
        if !hasPerformedSideEffect {
            DispatchQueue.main.async {
                // Perform side effect, e.g. fetch data, update external data source
                hasPerformedSideEffect = true
            }
        }

        // Other UI components
        Text("Hello, World!")
    }
}

import { useEffect } from "react";

function SideEffectOnLoadComponent() {
  useEffect(() => {
    // Perform side effect, e.g. fetch data, update external data source
  }, []);

  // Other UI components
  return <div />;
}

class SideEffectOnLoadComponent extends StatefulWidget {
  @override
  _SideEffectOnLoadComponentState createState() => _SideEffectOnLoadComponentState();
}

class _SideEffectOnLoadComponentState extends State<SideEffectOnLoadComponent> {
  @override
  void initState() {
    super.initState();
    // Perform side effect, e.g. fetch data, update external data source
  }

  @override
  Widget build(BuildContext context) {
    // Other UI components
    return Container();
  }
}