import Test from "./test.js";
// ASSERT will throw an error if strict equal comparison fails
import { ASSERT } from "./debug.js"; 

// the function to be tested
const sum = (...arg) => {
    // ...
    // if something goes wrong
    // throw it with no mercy!!
    if(!arg.length){
        throw new Error("no arguments!");
    }
    // simply sum the arguments
    return arg.reduce((prev, curr) => {
        return curr + prev
    }, 0)
}

// define your test
const test = new Test("2 + 2 shuld return 4", (N) => {
    ASSERT(sum(2, 2), 4)

    // test the 1 + 2 + 3 + ... + N serie
    var args = []
    for(var i = 1; i <= N; i++) {
        args.push(i)
    }
    ASSERT(sum.apply(this, args), N * (N + 1) / 2 )
})

// run it!
test.run(100)

// import the library
import * from dom from "./dom.js";

// you can use your own elements
const myTitle = document.createElement('h2')

// print a dom fragment in the body
document.body.appendChild(dom.html `
    <article>
        ${myTitle}
    </article>
`)

// of course you can handle your element after it has been printed 
myTitle.innerHTML = 'hello world'

const myTitle2 = document.createElement('h2')

// print a dom fragment in the body... in emmet dialect!
document.body.appendChild(
    dom.emmet `article>${myTitle2}.title>span{hello }`
)

// of course you can still handle your element after
myTitle2.innerHTML += 'emmet!'

import observable from "./observe.js"

// take your class
class FireworkClass {
    now(...args){
        // do some magic stuff
        // then...
        this.fire('fireworks!', ...args)
        this.schedule()
    }
    // never stop the fireworks <3
    schedule() {
        setTimeout(
            this.now.bind(this),
            Math.random() * 500
        )
    }
}
// and inject the interface
observable.call(FireworkClass.prototype)

// ...

// create instance
let firework = new FireworkClass()

// add an event handler for both the events
firework.on('fireworks!', (...args) => {
    console.log('this fireworks are beautiful', ...args)
})

// ...

// let's do the fireworks now!
firework.now( /* [...args] */ )

import reactive from "./reactive.js"

// define MyReactiveClass
class MyReactiveClass {
    constructor() {
        // make magicProperty bindable
        this.bindable("magicProperty")
    }
}
// add reactive inteface to MyReactiveClass's prototype
reactive.call(MyReactiveClass.prototype)

// create instance
let myReactiveInstance = new MyReactiveClass()
let myObj = {} // given an object
// you can bind the
// magicProperty of myReactiveInstance
// to myObj's magicProperty
myReactiveInstance.bind('magicProperty', myObj)

myReactiveInstance.magicProperty = 'hello reactive!'
// will print 'hello reactive!'
console.log(myObj.magicProperty)

// you can of course bind a reactive object
// with different properties another object
let element = document.querySelector('#my-element')
if(element) {
    myReactiveInstance.bind(
        'magicProperty',
        element,
        'innerHTML'
    )
    // the html content of #my-element
    // will be updated when the magicProperty change
}
myReactiveInstance.magicProperty = 'hello again!'

// and you can surely use it with functions
myReactiveInstance.bind(
    'magicProperty',
    console.log.bind(console)
)

// now we will also print the magicProperty value
// in console when the magicProperty change
myReactiveInstance.magicProperty = 'woooow!!'