var a = "lindo";
var b = "bbk";
console.log(`Victor é ${a} and
também é ${b}.`);

const palavrasApenas = [
    "almofada",
    "chafariz",
    "salamanda",
];

const palavrasApenasComNumeros = [
    "almofada": 1,
    "chafariz": 2,
    "salamanda": 3,
];

const byte = 2 ** 8;

const pessoasPresentes = ["Josefina", "Mário Alberto"];
pessoasPresentes.includes("Josefina"); // true
pessoasPresentes.includes("Stephanie"); // false

async function getOrgs(user) {
    const url =
        `https://api.github.com/users/${user}/orgs`;
    const orgs = await fetch(url).then(res => res.json());
    return orgs;
}

const peopleById = {
    dygufa: "Rodrigo Araújo",
    vhfmag: "Victor Magalhães",
};

const ids = Object.keys(peopleById);
const names = Object.values(peopleById);
for (const [id, name] of Object.entries(peopleById) {
    console.log(`id: ${id}, nome: ${name}`);
}

function formatDate(date) {
    const month = date.getMonth() + 1;
    const date = date.getDate();
    const year = date.getFullYear();

    return [date, month, year]
        .map(x => x.toString().padStart(2, "0"))
        .join("/");
}

formatDate(new Date); // "10/05/2018"

({a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40});
console.log(a); // 10
console.log(b); // 20
console.log(rest); //{c: 30, d: 40}

import React from "react";
import { render } from "react-dom";

const sleep = (n) => new Promise(res => setTimeout(res, n));

async function* ping(n) {
  let count = 0;
  while (true) {
    await sleep(n);
    yield ++count;
  }
}

class App extends React.Component {
  state = { seconds: 0 };

  async componentDidMount() {
    for await (const seconds of ping(1000)) this.setState({ seconds });
  }

  render() {
    return (
      <div>
        <img src="https://media1.giphy.com/media/qQx7B5z3hG19K/giphy.gif" />
        <h2>You have been rickrolled for {this.state.seconds} seconds</h2>
      </div>
    );
  }
}

render(<App />, document.getElementById("root"));

fetch("some.api/endpoint")
    .then(res => res.json())
    .catch(() => new Error("oh shit"))
    .finally(() => model.cleanStuff())

const dateRegexp = /(?<date>\d+)\/(?<month>\d+)\/(?<year>\d+)/;

let {
    groups: { date, year, month }
} = dateRegexp.exec("12/01/2018")

const pessoas = [
    { name: "Victor", grades: [8, 5, 8] },
    { name: "Dygufa", grades: [9, 7, 6] },
    { name: "Clara", grades: [8.5, 5, 9] },
];

const todasAsNotas = pessoas
    .flatMap(({ grades }) => grades);
const todasAsNotas2 = pessoas
    .map(({ grades }) => grades)
    .flatten();

const pessoas = [
    { name: "Victor", grades: [8, 5, 8] },
    { name: "Dygufa", grades: [9, 7, 6] },
    { name: "Clara", grades: [8.5, 5, 9] },
];

const todasAsNotas = pessoas
    .flatMap(({ grades }) => grades);
const todasAsNotas2 = pessoas
    .map(({ grades }) => grades)
    .flatten();

class Store {
    #user = null;
    lastUpdated = new Date();
    
    async fetchUser() {
        const res = await fetch(/**/);
        this.#user = await res.json();
        this.#onUpdate();
    }
    
    #onUpdate() {
        this.lastUpdated = new Date();
    }
}

import { flatMap } from "lodash";

async function getAllCells(src) {
    if (src instanceof File) {
        const XLSX = await import("xlsx");
        return flatMap(XLSX.fromFile(src).sheets[0]);
    } else {
        return flatMap(src, x => x);
    }
}

@autobind
class Store {
    @observable user = null;
    
    async fetchUser(id) {
        return await fetch(/**/)
            .then(res => res.json());
    }

    @action clearUser() {
        this.user = null;
    }

    @computed userId() {
        return this.user && this.user.id;
    }
}

class Utils {
    static #parseDate(raw) {
        return moment(raw).toDate();
    }

    static parseUser(raw) {
        return { ...raw, birthday: Utils.#parseDate(raw) };
    }
}

function getEncoder(encoding = throw new Error("Argument required")) {
  return encoding === "utf8" ? new UTF8Encoder() 
    : encoding === "utf16le" ? new UTF16Encoder(false) 
    : encoding === "utf16be" ? new UTF16Encoder(true) 
    : throw new Error("Unsupported encoding");
}

function listen(element, eventName) {
    return new Observable(observer => {
        // Create an event handler which sends data to the sink
        let handler = event => observer.next(event);

        // Attach the event handler
        element.addEventListener(eventName, handler, true);

        // Return a cleanup function which will cancel the event stream
        return () => {
            // Detach the event handler from the element
            element.removeEventListener(eventName, handler, true);
        };
    });
}

new CivilDate(year, month, day);
new CivilTime(hour, minute[[[, second], millisecond], nanosecond]);
new CivilDateTime(year, month, day, hour, minute, [...]);

new Instant(milliseconds[, nanoseconds]);
new ZonedInstant(instant, timeZone);

const doubleSay = (str) => str + ", " + str;

const capitalize = ([first, ...rest]) =>
    first.toUpperCase() + rest.join("");

const exclaim = (str) => str + '!';

let result1 = exclaim(capitalize(doubleSay("hello")));

let result2 = "hello"
  |> doubleSay
  |> capitalize
  |> exclaim;

result1 // "Hello, hello!"
result1 === result2 // true

let newScore = player.score
  |> somar(7, ?)
  |> limitar(0, 100, ?);

const maxGreaterThanZero = Math.max(0, ...);
maxGreaterThanZero(1, 2); // 2
maxGreaterThanZero(-1, -2); // 0

async function makeRequest(options) {
    const maxCacheTime = options?.maxCacheTime ?? 1E4;
    const skipHandshake = options?.skipHandshake ?? true;
    const userName = options?.userName ?? "@anonymous";
    // do stuff
}

return (
  <nav>
    <Home />
    {
      do {
        if (loggedIn) {
          <LogoutButton />
        } else {
          <LoginButton />
        }
      }
    }
  </nav>
)

const grades = [9, 8, 10, 5, 7];
const someGrades = grades[2:4];
const tail = grades[1:];
const evens = grades[::2];
const odds = grades[1::2];
const reverse = grades[::-1];

const res = await fetch(jsonService)
const val = match (res) {
  {status: 200, headers: {'Content-Length': s}} => `size is ${s}`,
  {status: 404} => 'JSON not found',
  {status} if (status >= 400) => throw new RequestError(res)
}

return (
    <Fetch url={API_URL}>{
      props => match (props) {
        {loading} if (loading) => <Loading />,
        {error} => <Error error={error} />,
        {data} => <Page data={data} />
      }
    }</Fetch>
);