Reactivity

Declare state

Vue 3

<script setup>
import { ref } from "vue";
const name = ref("John");
</script>

<template>
  <h1>Hello {{ name }}</h1>
</template>

Ripple

import { track } from "ripple";

export default function Name() {
  let &[name] = track("John");

  return <h1>"Hello "{name}</h1>;
}

Update state

Vue 3

<script setup>
import { ref } from "vue";
const name = ref("John");
name.value = "Jane";
</script>

<template>
  <h1>Hello {{ name }}</h1>
</template>

Ripple

import { track } from "ripple";

export default function Name() {
  let &[name] = track("John");
  name = "Jane";

  return <h1>"Hello "{name}</h1>;
}

Computed state

Vue 3

<script setup>
import { ref, computed } from "vue";
const count = ref(10);
const doubleCount = computed(() => count.value * 2);
</script>

<template>
  <div>{{ doubleCount }}</div>
</template>

Ripple

import { track } from "ripple";

export default function DoubleCount() {
  let &[count] = track(10);
  let &[doubleCount] = track(() => count * 2);

  return <div>{doubleCount}</div>;
}

Templating

Minimal template

Vue 3

<template>
  <h1>Hello world</h1>
</template>

Ripple

export default function HelloWorld() {
  return <h1>"Hello world"</h1>;
}

Styling

Vue 3

<template>
  <h1 class="title">I am red</h1>
  <button style="font-size: 10rem">I am a button</button>
</template>

<style scoped>
.title {
  color: red;
}
</style>

Ripple

export default function CssStyle() {
  return <>
    <h1 class="title">"I am red"</h1>
    <button style={{ fontSize: "10rem" }}>"I am a button"</button>

    <style>
      .title {
        color: red;
      }
    </style>
  </>;
}

Loop

Vue 3

<script setup>
const colors = ["red", "green", "blue"];
</script>

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

Ripple

export default function Colors() {
  const colors = ["red", "green", "blue"];

  return <ul>
    for (const color of colors; key color) {
      <li>{color}</li>
    }
  </ul>;
}

Event click

Vue 3

<script setup>
import { ref } from "vue";
const count = ref(0);

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

<template>
  <p>Counter: {{ count }}</p>
  <button @click="incrementCount">+1</button>
</template>

Ripple

import { track } from "ripple";

export default function Counter() {
  let &[count] = track(0);

  function incrementCount() {
    count++;
  }

  return <>
    <p>"Count: "{count}</p>
    <button onClick={incrementCount}>"+1"</button>
  </>;
}

Dom ref

Vue 3

<script setup>
import { useTemplateRef, onMounted } from "vue";

const inputElement = useTemplateRef("inputElement");

onMounted(() => {
  inputElement.value.focus();
});
</script>

<template>
  <input ref="inputElement" />
</template>

Ripple

export default function InputFocused() {
  function autofocus(element) {
    element.focus();
  }

  return <input ref={autofocus} />;
}

Conditional

Vue 3

<script setup>
import { ref, computed } from "vue";
const TRAFFIC_LIGHTS = ["red", "orange", "green"];
const lightIndex = ref(0);

const light = computed(() => TRAFFIC_LIGHTS[lightIndex.value]);

function nextLight() {
  lightIndex.value = (lightIndex.value + 1) % TRAFFIC_LIGHTS.length;
}
</script>

<template>
  <button @click="nextLight">Next light</button>
  <p>Light is: {{ light }}</p>
  <p>
    You must
    <span v-if="light === 'red'">STOP</span>
    <span v-else-if="light === 'orange'">SLOW DOWN</span>
    <span v-else-if="light === 'green'">GO</span>
  </p>
</template>

Ripple

import { track } from "ripple";

const TRAFFIC_LIGHTS = ["red", "orange", "green"];

export default function TrafficLight() {
  let &[lightIndex] = track(0);

  let &[light] = track(() => TRAFFIC_LIGHTS[lightIndex]);

  function nextLight() {
    lightIndex = (lightIndex + 1) % TRAFFIC_LIGHTS.length;
  }

  return <>
    <button onClick={nextLight}>"Next light"</button>
    <p>"Light is "{light}</p>
    <p>
      "You must "
      if (light === "red") {
        <span>"STOP"</span>
      } else if (light === "orange") {
        <span>"SLOW DOWN"</span>
      } else if (light === "green") {
        <span>"GO"</span>
      }
    </p>
  </>;
}

Lifecycle

On mount

Vue 3

<script setup>
import { ref, onMounted } from "vue";
const pageTitle = ref("");
onMounted(() => {
  pageTitle.value = document.title;
});
</script>

<template>
  <p>Page title: {{ pageTitle }}</p>
</template>

Ripple

import { effect, track } from "ripple";

export default function PageTitle() {
  let &[pageTitle] = track("");

  effect(() => {
    pageTitle = document.title;
  });

  return <h1>"Page title: "{pageTitle}</h1>;
}

On unmount

Vue 3

<script setup>
import { ref, onUnmounted } from "vue";

const time = ref(new Date().toLocaleTimeString());

const timer = setInterval(() => {
  time.value = new Date().toLocaleTimeString();
}, 1000);

onUnmounted(() => {
  clearInterval(timer);
});
</script>

<template>
  <p>Current time: {{ time }}</p>
</template>

Ripple

import { effect, track } from "ripple";

export default function Time() {
  let &[time] = track(new Date().toLocaleTimeString());

  effect(() => {
    const timer = setInterval(() => {
      time = new Date().toLocaleTimeString();
    }, 1000);

    return () => clearInterval(timer);
  });

  return <h1>"Current time: "{time}</h1>;
}

Component composition

Props

Vue 3

<script setup>
import UserProfile from "./UserProfile.vue";
</script>

<template>
  <UserProfile
    name="John"
    :age="20"
    :favourite-colors="['green', 'blue', 'red']"
    is-available
  />
</template>

Ripple

import { UserProfile } from "./UserProfile.tsrx";

export function App() {
  return <UserProfile
    name="John"
    age={20}
    favouriteColors={["green", "blue", "red"]}
    isAvailable
  />;
}

Emit to parent

Vue 3

<script setup>
import { ref } from "vue";
import AnswerButton from "./AnswerButton.vue";

let isHappy = ref(true);

function onAnswerNo() {
  isHappy.value = false;
}

function onAnswerYes() {
  isHappy.value = true;
}
</script>

<template>
  <p>Are you happy?</p>
  <AnswerButton @yes="onAnswerYes" @no="onAnswerNo" />
  <p style="font-size: 50px">
    {{ isHappy ? "😀" : "😥" }}
  </p>
</template>

Ripple

import { track } from "ripple";

import { AnswerButton } from "./AnswerButton.tsrx";

export function App() {
  let &[isHappy] = track(true);

  function onAnswerNo() {
    isHappy = false;
  }

  function onAnswerYes() {
    isHappy = true;
  }

  return <>
    <p>"Are you happy?"</p>
    <AnswerButton onYes={onAnswerYes} onNo={onAnswerNo} />
    <p style={{ fontSize: "50px" }}>{isHappy ? "😀" : "😥"}</p>
  </>;
}

Slot

Vue 3

<script setup>
import FunnyButton from "./FunnyButton.vue";
</script>

<template>
  <FunnyButton> Click me! </FunnyButton>
</template>

Ripple

import { FunnyButton } from "./FunnyButton.tsrx";

export function App() {
  return <FunnyButton>"Click me!"</FunnyButton>;
}

Slot fallback

Vue 3

<script setup>
import FunnyButton from "./FunnyButton.vue";
</script>

<template>
  <FunnyButton />
  <FunnyButton> I got content! </FunnyButton>
</template>

Ripple

import { FunnyButton } from "./FunnyButton.tsrx";

export function App() {
  return <>
    <FunnyButton />
    <FunnyButton>"I got content!"</FunnyButton>
  </>;
}

Context

Vue 3

<script setup>
import { ref, provide } from "vue";
import UserProfile from "./UserProfile.vue";

const user = ref({
  id: 1,
  username: "unicorn42",
  email: "[email protected]",
});

function updateUsername(username) {
  user.value.username = username;
}

provide("user", { user, updateUsername });
</script>

<template>
  <h1>Welcome back, {{ user.username }}</h1>
  <UserProfile />
</template>

Ripple

import { RippleObject } from "ripple";

import { UserContext } from "./UserContext.tsrx";
import { UserProfile } from "./UserProfile.tsrx";

export function App() {
  const user = new RippleObject({
    id: 1,
    username: "unicorn42",
    email: "[email protected]",
  });

  UserContext.set(user);

  return <>
    <h1>"Welcome back, "{user.username}</h1>
    <UserProfile />
  </>;
}

Form input

Input text

Vue 3

<script setup>
import { ref } from "vue";
const text = ref("Hello World");
</script>

<template>
  <p>{{ text }}</p>
  <input v-model="text" />
</template>

Ripple

import { bindValue, track } from "ripple";

export default function InputHello() {
  let &[text, textTracked] = track("Hello world");

  return <>
    <p>{text}</p>
    <input ref={bindValue(textTracked)} />
  </>;
}

Checkbox

Vue 3

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

const isAvailable = ref(true);
</script>

<template>
  <input id="is-available" v-model="isAvailable" type="checkbox" />
  <label for="is-available">Is available</label>
</template>

Ripple

import { bindChecked, track } from "ripple";

export default function IsAvailable() {
  let &[isAvailable, isAvailableTracked] = track(false);

  return <>
    <input
      id="is-available"
      type="checkbox"
      ref={bindChecked(isAvailableTracked)}
    />
    <label for="is-available">"Is available"</label>
  </>;
}

Radio

Vue 3

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

const picked = ref("red");
</script>

<template>
  <div>Picked: {{ picked }}</div>

  <input id="blue-pill" v-model="picked" type="radio" value="blue" />
  <label for="blue-pill">Blue pill</label>

  <input id="red-pill" v-model="picked" type="radio" value="red" />
  <label for="red-pill">Red pill</label>
</template>

Ripple

import { bindGroup, track } from "ripple";

export default function PickPill() {
  let &[picked, pickedTracked] = track("red");

  return <>
    <div>"Picked: "{picked}</div>

    <input
      id="blue-pill"
      type="radio"
      value="blue"
      ref={bindGroup(pickedTracked)}
    />
    <label for="blue-pill">"Blue pill"</label>

    <input
      id="red-pill"
      type="radio"
      value="red"
      ref={bindGroup(pickedTracked)}
    />
    <label for="red-pill">"Red pill"</label>
  </>;
}

Select

Vue 3

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

const selectedColorId = ref(2);

const colors = [
  { id: 1, text: "red" },
  { id: 2, text: "blue" },
  { id: 3, text: "green" },
  { id: 4, text: "gray", isDisabled: true },
];
</script>

<template>
  <select v-model="selectedColorId">
    <option
      v-for="color in colors"
      :key="color.id"
      :value="color.id"
      :disabled="color.isDisabled"
    >
      {{ color.text }}
    </option>
  </select>
</template>

Ripple

import { bindValue, track } from "ripple";

const colors = [
  { id: 1, text: "red" },
  { id: 2, text: "blue" },
  { id: 3, text: "green" },
  { id: 4, text: "gray", isDisabled: true },
];

export default function ColorSelect() {
  let &[selectedColorId, selectedColorIdTracked] = track(2);

  return <select ref={bindValue(selectedColorIdTracked)}>
    for (const color of colors; key color.id) {
      <option value={color.id} disabled={color.isDisabled}>
        {color.text}
      </option>
    }
  </select>;
}

Webapp features

Render app

Vue 3

<!doctype html>
<html>
  <body>
    <div id="app"></div>
    <script type="module" src="./main.js"></script>
  </body>
</html>

Ripple

<!doctype html>
<html>
  <body>
    <div id="app"></div>
    <script type="module" src="./main.js"></script>
  </body>
</html>

Fetch data

Vue 3

<script setup>
import useFetchUsers from "./useFetchUsers";

const { isLoading, error, data: users } = useFetchUsers();
</script>

<template>
  <p v-if="isLoading">Fetching users...</p>
  <p v-else-if="error">An error ocurred while fetching users</p>
  <ul v-else-if="users">
    <li v-for="user in users" :key="user.login.uuid">
      <img :src="user.picture.thumbnail" alt="user" />
      <p>
        {{ user.name.first }}
        {{ user.name.last }}
      </p>
    </li>
  </ul>
</template>

Ripple

import { useFetchUsers } from "./useFetchUsers.tsrx";

export function App() {
  const data = useFetchUsers();

  return <>
    if (data.isLoading) {
      <p>"Fetching users..."</p>
    } else if (data.error) {
      <p>"An error occurred while fetching users"</p>
    } else if (data.users) {
      <ul>
        for (const user of data.users; key user.login.uuid) {
          <li>
            <img src={user.picture.thumbnail} alt="user" />
            <p>{user.name.first}" "{user.name.last}</p>
          </li>
        }
      </ul>
    }
  </>;
}

Reactivity #

Declare state #

Vue 3

Ripple

Update state #

Vue 3

Ripple

Computed state #

Vue 3

Ripple

Templating #

Minimal template #

Vue 3

Ripple

Styling #

Vue 3

Ripple

Loop #

Vue 3

Ripple

Event click #

Vue 3

Ripple

Dom ref #

Vue 3

Ripple

Conditional #

Vue 3

Ripple

Lifecycle #

On mount #

Vue 3

Ripple

On unmount #

Vue 3

Ripple

Component composition #

Props #

Vue 3

Ripple

Emit to parent #

Vue 3

Ripple

Slot #

Vue 3

Ripple

Slot fallback #

Vue 3

Ripple

Context #

Vue 3

Ripple

Form input #

Input text #

Vue 3

Ripple

Checkbox #

Vue 3

Ripple

Radio #

Vue 3

Ripple

Select #

Vue 3

Ripple

Webapp features #

Render app #

Vue 3

Ripple

Fetch data #

Vue 3

Ripple

Reactivity

Declare state

Update state

Computed state

Templating

Minimal template

Styling

Loop

Event click

Dom ref

Conditional

Lifecycle

On mount

On unmount

Component composition

Props

Emit to parent

Slot

Slot fallback

Context

Form input

Input text

Checkbox

Radio

Select

Webapp features

Render app

Fetch data