Compare Declarative Frameworks

<template>
  <div>{{ displayString }}</div>
</template>

<script setup>
import { defineProps } from 'vue';

const props = defineProps({
  displayString: String
});
</script>

class MyComponent extends StatelessWidget {
  final String displayString;

  MyComponent({required this.displayString});

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

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

<template>
  <intermediate-component :data="data" />
</template>

<script setup>
import { defineProps } from 'vue';
import IntermediateComponent from './IntermediateComponent.vue';

const props = defineProps({
  data: String
});
</script>

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")

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" />;

<template>
  <input
    type="text"
    v-model="text"
    placeholder="Enter text"
  />
</template>

<script setup>
import { ref } from 'vue';

const text = ref('');
</script>

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"),
    );
  }
}

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

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

<template>
  <ul>
    <li v-for="item in items" :key="item">
      {{ item }}
    </li>
  </ul>
</template>

<script setup>
import { defineProps } from 'vue';

const props = defineProps({
  items: Array
});
</script>

<!-- Usage -->
<list-component :items="['Item 1', 'Item 2', 'Item 3']"></list-component>

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)

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} />;

// ParentComponent.vue
<template>
  <div>
    <slot name="header"></slot>
    <slot name="content"></slot>
  </div>
</template>

// ChildComponent.vue
<template>
  <p>Child Content</p>
</template>

// Usage
<parent-component>
  <template v-slot:header>
    <h1>Header</h1>
  </template>
  <template v-slot:content>
    <child />
  </template>
</parent-component>

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");
  }
}

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

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

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

<template>
  <button @click="incrementCount">
    Count: {{ count }}
  </button>
</template>

<script setup>
import { ref } from 'vue';

const count = ref(0);

function incrementCount() {
  count.value++;
}
</script>

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"),
    );
  }
}

import { useState } from "react";

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

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

<template>
  <div></div>
</template>

<script setup>
import { onMounted } from 'vue';

onMounted(() => {
  // Perform side effect here
});
</script>

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();
  }
}

import { useEffect } from "react";

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

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