firefly-compiler 0.6.10 → 0.6.12

package/lux/Lux.ff

@@ -169,7 +169,7 @@ extend self: Lux {
         } finally {
             patchText(self)
             if(!self.element.keepChildren) {
-                doWhile {removeCurrentChild(self)}
+                doWhile {removeCurrentChild(self, self.depth)}
             }
             patchAttributes(self)
             self.depth -= 1
@@ -268,10 +268,24 @@ extend self: Lux {
     onClick(handler: LuxEvent => Unit) {self.on("click", handler)}
     onInput(handler: LuxEvent => Unit) {self.on("input", handler)}
 
-    useState[T: HasAnyTag](initialValue: T, body: (T, T => Unit) => Unit) {
-        self.dry.map {_ => body(initialValue, {_ => })}.else:
+    useHook[T](body: LuxHook[T] => Unit) {
+        // if(!self.canHook) {throw(LuxHookException)}
+        // self.canHook = False
         self.depth += 1
-        let value = getStateOnElement(self.element.element, self.depth, initialValue)
+        try {
+            if(self.dry.isEmpty()) {
+                self.element.element.set("_lux$C" + self.depth, {}!)
+            }
+            body(LuxHook(self.Lux(element = self.element.LuxElement())))
+        } finally {
+            self.depth -= 1
+        }
+    }
+
+    useState[T: HasAnyTag](initialValue: T, body: (T, T => Unit) => Unit) {
+        self.useHook: hook =>
+        if(hook.dry()) {body(initialValue, {_ => })} else:
+        let value = if(hook.hasValue()) {hook.grabValue()} else {initialValue}
         mutable i = 0
         while {i < self.renderQueue.size()} {
             let item = self.renderQueue.grab(i)
@@ -281,109 +295,79 @@ extend self: Lux {
                 i += 1
             }
         }
-        let luxCopy = self.Lux(element = self.element.LuxElement())
         function setState(newValue: T): Unit {
-            setStateOnElement(luxCopy.element.element, luxCopy.depth, newValue)
+            hook.setValue(newValue)
             self.renderQueue.push(RenderQueueItem(
-                luxCopy = luxCopy
+                luxCopy = hook.luxCopy
                 render = {
-                    let child = luxCopy.element.child
-                    let element = luxCopy.element.childAt(child)
                     body(newValue, {setState(_)})
-                    if(!element.equals(luxCopy.element.childAt(child))) {
-                        removeCurrentChild(luxCopy.Lux(
-                            element = luxCopy.element.LuxElement(child = luxCopy.element.child + 1)
-                        ))
-                    }
                 }
             ))
         }
-        try {
-            body(value, {setState(_)})
-        } finally {
-            self.depth -= 1
-        }
+        body(value, {setState(_)})
     }
 
-    useCallback1[A1: Equal: HasAnyTag](callback: A1 => Unit, body: (A1 => Unit) => Unit) {
-        self.dry.map {_ => body(callback)}.else:
-        self.depth += 1
-        setStateOnElement(self.element.element, self.depth, callback)
-        let element = self.element.element
-        let depth = self.depth
-        try {
-            body {a1 =>
-                let latestCallback = getStateOnElement(element, depth, callback)
+    useCallback1[A1](callback: A1 => Unit, body: (A1 => Unit) => Unit) {
+        self.useHook: hook =>
+        if(hook.dry()) {body(callback)} else:
+        hook.setValue(callback)
+        body {a1 =>
+            let latestCallback = hook.grabValue()
+            self.renderLock.do {
                 latestCallback(a1)
+                processRenderQueue(self)
             }
-        } finally {
-            self.depth -= 1
         }
     }
 
     useLazy1[A1: Equal: HasAnyTag](a1: A1, body: A1 => Unit = {_ => }) {
-        self.dry.map {_ => body(a1)}.else:
-        self.depth += 1
-        try {
-            let old = getStateOnElement(self.element.element, self.depth, None)
-            old.{
-                | Some(o1) {a1 == o1} =>
-                    self.element.keepChildren = True
-                | _ =>
-                    setStateOnElement(self.element.element, self.depth, Some(a1))
-                    body(a1)
-            }
-        } finally {
-            self.depth -= 1
+        self.useHook: hook =>
+        if(hook.dry()) {body(a1)} else:
+        if(!hook.hasValue() || hook.grabValue() != a1) {
+            hook.setValue(a1)
+            body(a1)
+        } else {
+            self.element.keepChildren = True
         }
     }
 
     useMemo1[A1: Equal: HasAnyTag, T: HasAnyTag](a1: A1, compute: A1 => T, body: T => Unit) {
-        self.dry.map {_ => body(compute(a1))}.else:
-        self.depth += 1
-        try {
-            let old = getStateOnElement(self.element.element, self.depth, Pair(a1, None))
-            let computed = old.{
-                | Pair(o1, _) {a1 != o1} => 
-                    let v = compute(a1)
-                    setStateOnElement(self.element.element, self.depth, Pair(a1, Some(v)))
-                    v
-                | Pair(_, Some(v)) => 
-                    v
-                | Pair(_, None) =>
-                    let v = compute(a1)
-                    setStateOnElement(self.element.element, self.depth, Pair(a1, Some(v)))
-                    v
+        self.useHook: hook =>
+        if(hook.dry()) {body(compute(a1))} else:
+        if(hook.hasValue()) {
+            let pair: Pair[A1, T] = hook.grabValue()
+            if(pair.first == a1) {
+                body(pair.second)
+            } else {
+                let value = compute(a1)
+                hook.setValue(Pair(a1, value))
+                body(value)
             }
-            body(computed)
-        } finally {
-            self.depth -= 1
+        } else {
+            let value = compute(a1)
+            hook.setValue(Pair(a1, value))
+            body(value)
         }
     }
-    
+
     useSuspense(suspense: () => Unit, body: Lux => Unit) {
-        self.dry.map {_ => suspense()}.else:
-        let oldSubtask = getTaskOnElement(self.element.element)
-        oldSubtask.each {task =>
-            forceAsyncAbort(self, task)
-        }
-        let fragment = self.document.createFragment()
-        let luxCopy = self.Lux(element = self.element.LuxElement())
-        let subtask = self.task.spawn {task =>
-            let lux = luxCopy.Lux(
+        self.useHook: hook =>
+        if(hook.dry()) {suspense()} else:
+        hook.cleanup()
+        let fragment = hook.luxCopy.document.createFragment()
+        let subtask = hook.luxCopy.task.spawn {task =>
+            let lux = hook.luxCopy.Lux(
                 task = task
                 renderLock = task.lock()
                 renderQueue = Array.new()
-                element = luxCopy.element.LuxElement(element = fragment)
+                element = hook.luxCopy.element.LuxElement(element = fragment)
             )
             try {
                 body(lux)
                 task.throwIfAborted()
-                lux.copyFrom(luxCopy)
+                lux.copyFrom(hook.luxCopy)
                 lux.renderLock.do {
-                    abortTasksOnElement(lux, lux.element.childAt(lux.element.child), onlyChildren = True)
-                    lux.element.removeAt(lux.element.child)
-                    lux.element.insertBefore(fragment, lux.jsSystem.null())
+                    replaceWithFragment(lux.element.element, fragment, lux.depth)
                 }
             } catchAny {error =>
                 if(error.name() != "AbortError") {
@@ -391,10 +375,128 @@ extend self: Lux {
                 }
             }
         }
+        hook.setCleanup {subtask.abort()}
         suspense()
-        setTaskOnElement(self.element.childAt(self.element.child - 1), Some(subtask))
     }
 
+    useWebSocket(
+        url: String
+        onMessage: Buffer => Unit
+        body: (Buffer => Unit) => Unit
+    ) {
+        self.useHook: hook =>
+        if(hook.dry()) {} else:
+        self.useCallback1 {buffer => 
+            onMessage(buffer)
+        }: onMessage =>
+        function createWebSocket(): JsValue {
+            let socket = Js->WebSocket->(url)
+            hook.setValue(Pair(socket, url))
+            hook.setCleanup {
+                socket->close()
+            }
+            socket->binaryType = "arraybuffer"
+            Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                socket->onopen = Js->{resolve(Unit)}
+                socket->onclose = Js->{reject(_?)}
+            }
+            socket->onopen = Js.null()
+            socket->onclose = Js.null()
+            socket->addEventListener("close", Js->{
+                Log.debug("Closed")
+            })
+            socket->addEventListener("message", Js->{m =>
+                let buffer = Js->DataView->(m->data).grabBuffer() // TODO: Handle text
+                onMessage(buffer)
+            })
+            socket->addEventListener("error", Js->{e =>
+                Log.debug("Error")
+            })
+            socket
+        }
+        let socket = if(!hook.hasValue()) {
+            createWebSocket()
+        } else {
+            let pair = hook.grabValue()
+            let oldSocket: JsValue = pair.first
+            let oldUrl: String = pair.second
+            if(oldUrl == url) {
+                oldSocket
+            } else {
+                hook.cleanup()
+                createWebSocket()
+            }
+        }
+        let send: Buffer => Unit = {buffer => socket->send(buffer)}
+        body(send)
+    }
+
+}
+
+capability LuxHook[T](luxCopy: Lux)
+
+extend self[T]: LuxHook[T] {
+    dry(): Bool {
+        !self.luxCopy.dry.isEmpty()
+    }
+    setValue(value: T) {
+        self.luxCopy.element.element.set("_lux$S" + self.luxCopy.depth, value!)
+    }
+    hasValue(): Bool {
+        self.luxCopy.element.element.hasOwn("_lux$S" + self.luxCopy.depth)
+    }
+    grabValue(): T {
+        let value = self.luxCopy.element.element.get("_lux$S" + self.luxCopy.depth)
+        if(value.isUndefined() && !self.hasValue()) {
+            throw(GrabException)
+        }
+        value? // If value is an async function, will the effect type system see through this?
+    }
+    setCleanup(body: () => Unit) {
+        self.luxCopy.element.element.set("_lux$C" + self.luxCopy.depth, body!)
+    }
+    cleanup() {
+        let key = "_lux$C" + self.luxCopy.depth
+        let cleanupFunction = self.luxCopy.element.element.get(key)
+        self.luxCopy.element.element.set(key, {}!)
+        cleanupFunction?() // Async cleanup is not waited for. Is that ok?
+    }
+}
+
+cleanupElement(element: JsValue, depth: Int) {
+    mutable d = depth
+    doWhile {
+        let cleanupFunction = element.get("_lux$C" + d)
+        if(cleanupFunction.isUndefined()) {
+            False
+        } else {
+            Js->Reflect->deleteProperty(element, "_lux$C" + d)
+            Js->Reflect->deleteProperty(element, "_lux$S" + d)
+            cleanupFunction?() // Async cleanup is not waited for. Is that ok?
+            d += 1
+            True
+        }
+    }
+    element->children.each {child => 
+        cleanupElement(child, d + 1)
+    }
+}
+
+replaceWithFragment(element: JsValue, fragment: JsValue, depth: Int) {
+    cleanupElement(element, depth) // Assumes that hooks have no siblings
+    mutable d = depth
+    doWhile {
+        let cleanupFunction = fragment.get("_lux$C" + d)
+        if(cleanupFunction.isUndefined()) {
+            False
+        } else {
+            element.set("_lux$C" + d, cleanupFunction)
+            if(fragment.hasOwn("_lux$S" + d)) {element.set("_lux$S" + d, fragment.get("_lux$S" + d))}
+            d += 1
+            True
+        }
+    }
+    element->replaceChildren(fragment)
 }
 
 processRenderQueue(self: Lux) {
@@ -411,50 +513,14 @@ processRenderQueue(self: Lux) {
     }
 }
 
-removeCurrentChild(self: Lux): Bool {
+removeCurrentChild(self: Lux, depth: Int): Bool {
     let child = self.element.childAt(self.element.child)
     if(!child.isNullOrUndefined() && !child->children.isNullOrUndefined()) {
-        abortTasksOnElement(self, child, False)
+        cleanupElement(child, depth)
     }
     self.element.removeAt(self.element.child)
 }
 
-getStateOnElement[T /*: HasAnyTag*/](element: JsValue, depth: Int, fallback: T): T {
-    let value = element.get("lux" + depth)
-    if(value.isNullOrUndefined()) {fallback} else {
-        value?
-    }
-}
-
-setStateOnElement[T /*: HasAnyTag*/](element: JsValue, depth: Int, value: T): Unit {
-    element.set("lux" + depth, value!)
-}
-
-
-getTaskOnElement(element: JsValue): Option[Task] {
-    let value = element->luxTask
-    if(value.isNullOrUndefined()) {None} else {
-        value?
-    }
-}
-
-setTaskOnElement(element: JsValue, task: Option[Task]): Unit {
-    element->luxTask = task!
-}
-
-abortTasksOnElement(lux: Lux, element: JsValue, onlyChildren: Bool): Unit {
-    if(!onlyChildren) {
-        getTaskOnElement(element).each {task => forceAsyncAbort(lux, task)}
-    }
-    element->children.each {child => 
-        abortTasksOnElement(lux, child, False)
-    }
-}
-
-forceAsyncAbort(self: Lux, task: Task): Unit {
-    task.abort()
-}
-
 patchText(self: Lux) {
     if(!self.texts.isEmpty()):
     let value = self.texts.drain().join()

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.6.10",
+    "version": "0.6.12",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.6.10",
+    "version": "0.6.12",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/webserver/WebRoute.ff

@@ -75,7 +75,7 @@ extend self[P1: WebParameter]: WebRoute1[P1] {
 extend self[P1: WebParameter, P2: WebParameter]: WebRoute2[P1, P2] {
     toUrl(p1: P1, p2: P2): String {
         mutable result = ""
-        mutable parameter = 0
+        mutable parameter = 1
         self.segments.each {r =>
             if(r.startsWith("{")) {
                 let p = if(parameter == 1) {