import {param, returns} from 'decorate-this';
 
class Point {
    constructor() {
        this.x = 0;
        this.y = 0;
    }
 
    // The first param of this method takes a Point, and will throw
    // a type error if a non-Point is passed
    @param(Point)
    // The method returns a Number. If it doesn't, a type error will
    // be thrown before the value is returned.
    @returns(Number)
    distanceTo(point) {
        let squaredDistance = (point.x - this.x) ** 2 +
            (point.y - this.y) ** 2;
 
        return Math.sqrt(squaredDistance);
    }
 
    // Two number args, no return value
    @param(Number)
    @param(Number)
    addToDimensions(x, y) {
        this.x += x;
        this.y += y;
    }
}

import memoize from 'decorate-this';
let obj = {
    // Results of the function are stored in a map, which maps arguments
    // to the function's result. This expensive func is only run a single
    // time for a given a/b pair.
    @memoize
    expensiveFunc(a, b) {
        return Math.sin(Math.sqrt(a ** b));
    }
};

import {enumerable, writable, configurable} from 'decorate-this';
 
class T {
    @configurable(false)
    @enumerable(false)
    @writable(false)
    hiddenMethod() {
        /* ... */
    }
}

let obj = {
    @curry
    curriedAdd(a, b, c) {
        return a + b + c;
    }
}
 
let addToFive = obj.curriedAdd(5);   // Function
let addToFiveAndThree = addToFive(3);  // Function
let sum = addToFiveAndThree(7);      // 15

let obj = {
    @debounce(500) // call after 500ms of no further calls
    debouncedFn(event) {
        console.log(event.clientX, event.clientY);
    }
}

let obj = {
    @promises(ArrayOf(Number))
    getPoints() {
        return new Promise(resolve => {
            setTimeout(() => resolve([1, 2, 3]), 5000);
        });
    }
}