// This is a single line comment

/*
  This is a multi line comment.
  It can have as many lines as you need.
*/

var myVariable = "This is the value.";

var iceCream = 'chocolate';
if (iceCream === 'chocolate') {
  alert('Yay, I love chocolate ice cream!');    
} else {
  alert('Awwww, but chocolate is my favorite...');    
}

// basic counter using a for loop
for (x = 1; x <= 10; x++) {
  console.log(x);
}

// Same counter using a while
var x = 1;
while (x <= 10) {
  console.log(x);
  x = x + 1;
}

alert('hello!');

function multiply(num1,num2) {
  var result = num1 * num2;
  return result;
}

multiply(4, 7);
multiply(20, 20);

function f() {
  {
    let x;
    {
      // this is ok since it's a block scoped name
      const x = "sneaky";
      // error, was just defined with `const` above
      x = "foo";
    }
    // this is ok since it was declared with `let`
    x = "bar";
    // error, already declared above in this block
    let x = "inner";
  }
}

// Expression bodies
var increment = x => x + 1;
var add = (x, y) => x + y;

increment(1); // returns 2
add(1, 2); returns 3

// Spread example
function f(x, y, z) {
  return x + y + z;
}
// Pass each elem of array as argument
f(...[1,2,3]) == 6


// Rest example
function f(x, ...y) {
  // y is an Array
  return x * y.length;
}
f(3, "hello", true) == 6

function timeout(duration = 0) {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, duration);
    });
}

var p = timeout(1000).then(() => {
    return timeout(2000);
}).then(() => {
    throw new Error("hmm");
}).catch(err => {
    return Promise.all([timeout(100), timeout(200)]);
});

// lib/math.js
export function sum(x, y) {
  return x + y;
}
export var pi = 3.141593;


// app.js
import * as math from "lib/math";
console.log("2π = " + math.sum(math.pi, math.pi));

class Rectangle { 
   constructor(height, width) { 
      this.h = height; 
      this.w = width;
   }

   area() {
      return this.w * this.h;
   }

   display() { 
      console.log("The height of the rectangle: ", this.h);
      console.log("The width of the rectangle: ",this. w);
   } 
} 

//creating an instance  
var rectangleObj = new Rectangle(10,20); 
rectangleObj.display();
console.log("The area of the rectangle: ", rectangleObj.area();

class StaticExample { 
   static disp() { 
      console.log("Static Function called");
   } 
}

StaticExample.disp(); //invoke the static method

// Static Function called

class Person{
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  display() {
    console(this.name, " is ", this.age, " years old.");
  }
} 
var obj = new Person() 
var isPerson = obj instanceof Person; 
console.log("obj is an instance of Person " + isPerson); 

// obj is an instance of Person True 

class Shape { 
   constructor(a) { 
      this.Area = a;
   } 
} 
class Circle extends Shape { 
   disp() { 
      console.log("Area of the circle: "+this.Area);
   } 
} 
var obj = new Circle(223); 
obj.disp();

// Area of the circle: 223

class Root { 
   test() { 
      console.log("call from parent class");
   } 
} 
class Child extends Root {} 
class Leaf extends Child {}

//indirectly inherits from Root via Child
var obj = new Leaf();
obj.test()

// call from parent class

class PrinterClass { 
   doPrint() { 
      console.log("doPrint() from Parent called… ");
   }
}
class StringPrinter extends PrinterClass { 
   doPrint() { 
      console.log("doPrint() is printing a string…"); 
   } 
} 
var obj = new StringPrinter(); 
obj.doPrint();

// doPrint() is printing a string… 

class PrinterClass { 
   doPrint() {
      console.log("doPrint() from Parent called…") 
   } 
}  
class StringPrinter extends PrinterClass { 
   doPrint() { 
      super.doPrint() 
      console.log("doPrint() is printing a string…") 
   } 
} 
var obj = new StringPrinter() 
obj.doPrint()

// doPrint() from Parent called. 
// doPrint() is printing a string. 

fetch('https://example.com/some/url')
  .then(function(response) {
	// process response
  })
  .catch(function(err) {
	// process error
  });

const request = new Request('https://example.com/some/url', {
  headers: new Headers({
      'Content-Type': 'text/plain'
  })
});

fetch(request).then(function() { /* handle response */ });

const request = new Request('https://example.com/some/url', {
  method: 'POST', 
  mode: 'cors', 
  redirect: 'follow',
  headers: new Headers({
    'Content-Type': 'text/plain'
  })
});

// Now use it!
fetch(request).then(function(response) { /* handle response */ });

// The fetch's `then` gets a Response instance back
fetch('https://example.com/some/url')
  .then(function(response) {
    console.log('status: ', response.status);
  });

fetch('https://example.com/some/url').then(function(response) { 
  // Convert to JSON
  return response.json();
}).then(function(j) {
  // Yay, `j` is a JavaScript object
  console.log(j); 
});