4970ae1 | gromer

git clone https://git.pyrossh.dev/gromer

gromer is a framework and cli to build multipage web apps in golang using htmx and alpinejs.

4970ae1 — pyros2097 2020-11-13T19:22:46+05:30

initial commit

Files changed (44) hide show

.gitattributes +2 -0
.gitignore +21 -0
LICENSE +21 -0
app.go +55 -0
app_nowasm.go +32 -0
app_wasm.go +100 -0
cmd/wapp/main.go +310 -0
component.go +380 -0
component_test.go +277 -0
concurrency.go +15 -0
condition.go +121 -0
condition_test.go +175 -0
context.go +20 -0
element.go +456 -0
element_test.go +367 -0
errors/README.md +17 -0
errors/errors.go +208 -0
errors/errors_test.go +153 -0
go.mod +12 -0
go.sum +31 -0
html.go +65 -0
js.go +224 -0
js_nowasm.go +150 -0
js_wasm.go +247 -0
log.go +48 -0
makefile +44 -0
node.go +203 -0
node_test.go +177 -0
range.go +151 -0
range_test.go +91 -0
raw.go +173 -0
raw_test.go +116 -0
readme.md +64 -0
resource.go +151 -0
resource_test.go +85 -0
storage.go +29 -0
storage_nowasm.go +39 -0
storage_test.go +154 -0
storage_wasm.go +72 -0
strings.go +45 -0
testing.go +289 -0
testing_test.go +46 -0
text.go +120 -0
text_test.go +103 -0

.gitattributes ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ # Auto detect text files and perform LF normalization
2	+ * text=auto

.gitignore ADDED Viewed

@@ -0,0 +1,21 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.app
+# Test binary, build with `go test -c`
+*.test
+test
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+# Static generated files
+*.gz
+*.gcloudignore
+*.wasm
+main

LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2016 Maxence Charriere
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.go ADDED Viewed

@@ -0,0 +1,55 @@
+package app
+import (
+	"strings"
+)
+var (
+	staticResourcesURL string
+)
+// KeepBodyClean prevents third-party Javascript libraries to add nodes to the
+// body element.
+func KeepBodyClean() (close func()) {
+	return keepBodyClean()
+}
+// Reload reloads the current page.
+func Reload() {
+	dispatch(func() {
+		reload()
+	})
+}
+// Run starts the wasm app and displays the UI node associated with the
+// requested URL path.
+//
+// It panics if Go architecture is not wasm.
+func Run(r RenderFunc) {
+	run(r)
+}
+// StaticResource makes a static resource path point to the right
+// location whether the root directory is remote or not.
+//
+// Static resources are resources located in the web directory.
+//
+// This call is used internally to resolve paths within Cite, Data, Href, Src,
+// and SrcSet. Paths already resolved are skipped.
+func StaticResource(path string) string {
+	if !strings.HasPrefix(path, "/web/") &&
+		!strings.HasPrefix(path, "web/") {
+		return path
+	}
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	return staticResourcesURL + path
+}
+// Window returns the JavaScript "window" object.
+func Window() BrowserWindow {
+	return window
+}

app_nowasm.go ADDED Viewed

@@ -0,0 +1,32 @@
+// +build !wasm
+package app
+import (
+	"net/url"
+	"os"
+)
+var (
+	window *browserWindow
+)
+func getenv(k string) string {
+	return os.Getenv(k)
+}
+func keepBodyClean() func() {
+	panic(errNoWasm)
+}
+func navigate(u *url.URL, updateHistory bool) error {
+	panic(errNoWasm)
+}
+func reload() {
+	panic(errNoWasm)
+}
+func run(r RenderFunc) {
+	panic(errNoWasm)
+}

app_wasm.go ADDED Viewed

@@ -0,0 +1,100 @@
+package app
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"syscall/js"
+)
+var (
+	body       *elem
+	content    UI
+	rootPrefix string
+	window     = &browserWindow{value: value{Value: js.Global()}}
+)
+func run(render RenderFunc) {
+	defer func() {
+		err := recover()
+		displayLoadError(err)
+		panic(err)
+	}()
+	initBody()
+	initContent()
+	if err := body.replaceChildAt(0, render); err != nil {
+		panic("replacing content failed")
+	}
+	content = render
+	for {
+		select {
+		case f := <-uiChan:
+			f()
+		}
+	}
+}
+func initBody() {
+	ctx, cancel := context.WithCancel(context.Background())
+	body = &elem{
+		ctx:       ctx,
+		ctxCancel: cancel,
+		jsvalue:   Window().Get("document").Get("body"),
+		tag:       "body",
+	}
+	body.setSelf(body)
+}
+func initContent() {
+	ctx, cancel := context.WithCancel(context.Background())
+	content := &elem{
+		ctx:       ctx,
+		ctxCancel: cancel,
+		jsvalue:   body.JSValue().Get("firstElementChild"),
+		tag:       "div",
+	}
+	content.setSelf(content)
+	content.setParent(body)
+	body.body = append(body.body, content)
+}
+func displayLoadError(err interface{}) {
+	loadingLabel := Window().
+		Get("document").
+		Call("getElementById", "app-wasm-loader-label")
+	if !loadingLabel.Truthy() {
+		return
+	}
+	loadingLabel.Set("innerText", fmt.Sprint(err))
+}
+func onPopState(this Value, args []Value) interface{} {
+	dispatch(func() {
+		// navigate(Window().URL(), false)
+	})
+	return nil
+}
+func isExternalNavigation(u *url.URL) bool {
+	return u.Host != "" && u.Host != Window().URL().Host
+}
+func isFragmentNavigation(u *url.URL) bool {
+	return u.Fragment != ""
+}
+func reload() {
+	Window().Get("location").Call("reload")
+}
+func keepBodyClean() func() {
+	close := Window().Call("goappKeepBodyClean")
+	return func() {
+		close.Invoke()
+	}
+}

cmd/wapp/main.go ADDED Viewed

@@ -0,0 +1,310 @@
+package main
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"plugin"
+	"strconv"
+	"strings"
+	"time"
+	"github.com/markbates/pkger"
+	app "github.com/pyros2097/wapp"
+	"gopkg.in/fsnotify.v1"
+)
+const wasmExecTemplate = `const enosys=()=>{const a=new Error("not implemented");return a.code="ENOSYS",a};let outputBuf="";window.fs={constants:{O_WRONLY:-1,O_RDWR:-1,O_CREAT:-1,O_TRUNC:-1,O_APPEND:-1,O_EXCL:-1},writeSync(a,b){outputBuf+=decoder.decode(b);const c=outputBuf.lastIndexOf("\n");return-1!=c&&(console.log(outputBuf.substr(0,c)),outputBuf=outputBuf.substr(c+1)),b.length},write(a,b,c,d,e,f){if(0!==c||d!==b.length||null!==e)return void f(enosys());const g=this.writeSync(a,b);f(null,g)}};const encoder=new TextEncoder("utf-8"),decoder=new TextDecoder("utf-8");class Go{constructor(){this.argv=["js"],this.env={},this.exit=a=>{0!==a&&console.warn("exit code:",a)},this._exitPromise=new Promise(a=>{this._resolveExitPromise=a}),this._pendingEvent=null,this._scheduledTimeouts=new Map,this._nextCallbackTimeoutID=1;const a=(a,b)=>{this.mem.setUint32(a+0,b,!0),this.mem.setUint32(a+4,Math.floor(b/4294967296),!0)},b=a=>{const b=this.mem.getUint32(a+0,!0),c=this.mem.getInt32(a+4,!0);return b+4294967296*c},c=a=>{const b=this.mem.getFloat64(a,!0);if(0!==b){if(!isNaN(b))return b;const c=this.mem.getUint32(a,!0);return this._values[c]}},d=(a,b)=>{const c=2146959360;if("number"==typeof b)return isNaN(b)?(this.mem.setUint32(a+4,2146959360,!0),void this.mem.setUint32(a,0,!0)):0===b?(this.mem.setUint32(a+4,2146959360,!0),void this.mem.setUint32(a,1,!0)):void this.mem.setFloat64(a,b,!0);switch(b){case void 0:return void this.mem.setFloat64(a,0,!0);case null:return this.mem.setUint32(a+4,c,!0),void this.mem.setUint32(a,2,!0);case!0:return this.mem.setUint32(a+4,c,!0),void this.mem.setUint32(a,3,!0);case!1:return this.mem.setUint32(a+4,c,!0),void this.mem.setUint32(a,4,!0);}let d=this._ids.get(b);d===void 0&&(d=this._idPool.pop(),d===void 0&&(d=this._values.length),this._values[d]=b,this._goRefCounts[d]=0,this._ids.set(b,d)),this._goRefCounts[d]++;let e=1;switch(typeof b){case"string":e=2;break;case"symbol":e=3;break;case"function":e=4;}this.mem.setUint32(a+4,2146959360|e,!0),this.mem.setUint32(a,d,!0)},e=a=>{const c=b(a+0),d=b(a+8);return new Uint8Array(this._inst.exports.mem.buffer,c,d)},f=d=>{const e=b(d+0),f=b(d+8),g=Array(f);for(let a=0;a<f;a++)g[a]=c(e+8*a);return g},g=a=>{const c=b(a+0),d=b(a+8);return decoder.decode(new DataView(this._inst.exports.mem.buffer,c,d))},h=Date.now()-performance.now();this.importObject={go:{"runtime.wasmExit":a=>{const b=this.mem.getInt32(a+8,!0);this.exited=!0,delete this._inst,delete this._values,delete this._goRefCounts,delete this._ids,delete this._idPool,this.exit(b)},"runtime.wasmWrite":a=>{const c=b(a+8),d=b(a+16),e=this.mem.getInt32(a+24,!0);fs.writeSync(c,new Uint8Array(this._inst.exports.mem.buffer,d,e))},"runtime.resetMemoryDataView":()=>{this.mem=new DataView(this._inst.exports.mem.buffer)},"runtime.nanotime1":b=>{a(b+8,1e6*(h+performance.now()))},"runtime.walltime1":b=>{const c=new Date().getTime();a(b+8,c/1e3),this.mem.setInt32(b+16,1e6*(c%1e3),!0)},"runtime.scheduleTimeoutEvent":a=>{const c=this._nextCallbackTimeoutID;this._nextCallbackTimeoutID++,this._scheduledTimeouts.set(c,setTimeout(()=>{for(this._resume();this._scheduledTimeouts.has(c);)console.warn("scheduleTimeoutEvent: missed timeout event"),this._resume()},b(a+8)+1)),this.mem.setInt32(a+16,c,!0)},"runtime.clearTimeoutEvent":a=>{const b=this.mem.getInt32(a+8,!0);clearTimeout(this._scheduledTimeouts.get(b)),this._scheduledTimeouts.delete(b)},"runtime.getRandomData":a=>{crypto.getRandomValues(e(a+8))},"syscall/js.finalizeRef":a=>{const b=this.mem.getUint32(a+8,!0);if(this._goRefCounts[b]--,0===this._goRefCounts[b]){const a=this._values[b];this._values[b]=null,this._ids.delete(a),this._idPool.push(b)}},"syscall/js.stringVal":a=>{d(a+24,g(a+8))},"syscall/js.valueGet":a=>{const b=Reflect.get(c(a+8),g(a+16));a=this._inst.exports.getsp(),d(a+32,b)},"syscall/js.valueSet":a=>{Reflect.set(c(a+8),g(a+16),c(a+32))},"syscall/js.valueDelete":a=>{Reflect.deleteProperty(c(a+8),g(a+16))},"syscall/js.valueIndex":a=>{d(a+24,Reflect.get(c(a+8),b(a+16)))},"syscall/js.valueSetIndex":a=>{Reflect.set(c(a+8),b(a+16),c(a+24))},"syscall/js.valueCall":a=>{try{const b=c(a+8),e=Reflect.get(b,g(a+16)),h=f(a+32),i=Reflect.apply(e,b,h);a=this._inst.exports.getsp(),d(a+56,i),this.mem.setUint8(a+64,1)}catch(b){d(a+56,b),this.mem.setUint8(a+64,0)}},"syscall/js.valueInvoke":a=>{try{const b=c(a+8),e=f(a+16),g=Reflect.apply(b,void 0,e);a=this._inst.exports.getsp(),d(a+40,g),this.mem.setUint8(a+48,1)}catch(b){d(a+40,b),this.mem.setUint8(a+48,0)}},"syscall/js.valueNew":a=>{try{const b=c(a+8),e=f(a+16),g=Reflect.construct(b,e);a=this._inst.exports.getsp(),d(a+40,g),this.mem.setUint8(a+48,1)}catch(b){d(a+40,b),this.mem.setUint8(a+48,0)}},"syscall/js.valueLength":b=>{a(b+16,parseInt(c(b+8).length))},"syscall/js.valuePrepareString":b=>{const e=encoder.encode(c(b+8)+"");d(b+16,e),a(b+24,e.length)},"syscall/js.valueLoadString":a=>{const b=c(a+8);e(a+16).set(b)},"syscall/js.valueInstanceOf":a=>{this.mem.setUint8(a+24,c(a+8)instanceof c(a+16))},"syscall/js.copyBytesToGo":b=>{const d=e(b+8),f=c(b+32);if(!(f instanceof Uint8Array))return void this.mem.setUint8(b+48,0);const g=f.subarray(0,d.length);d.set(g),a(b+40,g.length),this.mem.setUint8(b+48,1)},"syscall/js.copyBytesToJS":b=>{const d=c(b+8),f=e(b+16);if(!(d instanceof Uint8Array))return void this.mem.setUint8(b+48,0);const g=f.subarray(0,d.length);d.set(g),a(b+40,g.length),this.mem.setUint8(b+48,1)},debug:a=>{console.log(a)}}}}async run(a){this._inst=a,this.mem=new DataView(this._inst.exports.mem.buffer),this._values=[NaN,0,null,!0,!1,window,this],this._goRefCounts=[],this._ids=new Map,this._idPool=[],this.exited=!1;let b=4096;const c=a=>{const c=b,d=encoder.encode(a+"\0");return new Uint8Array(this.mem.buffer,b,d.length).set(d),b+=d.length,0!=b%8&&(b+=8-b%8),c},d=this.argv.length,e=[];this.argv.forEach(a=>{e.push(c(a))}),e.push(0);const f=Object.keys(this.env).sort();f.forEach(a=>{e.push(c(a+"="+this.env[a]))}),e.push(0);const g=b;e.forEach(a=>{this.mem.setUint32(b,a,!0),this.mem.setUint32(b+4,0,!0),b+=8}),this._inst.exports.run(d,g),this.exited&&this._resolveExitPromise(),await this._exitPromise}_resume(){if(this.exited)throw new Error("Go program has already exited");this._inst.exports.resume(),this.exited&&this._resolveExitPromise()}_makeFuncWrapper(a){const b=this;return function(){const c={id:a,this:this,args:arguments};return b._pendingEvent=c,b._resume(),c.result}}}const go=new Go;WebAssembly.instantiateStreaming(fetch("__path__"),go.importObject).then(a=>go.run(a.instance)).catch(a=>console.error("could not load wasm",a));`
+func wasmExecJs(path string) string {
+	return strings.Replace(wasmExecTemplate, "__path__", path, 1)
+}
+var watchDelta = 1000 * time.Millisecond
+type Watcher struct {
+	rootdir     string
+	watcher     *fsnotify.Watcher
+	watchVendor bool
+	update      chan string
+}
+// MustRegisterWatcher creates a new Watcher and starts listening to
+// given folders
+func MustRegisterWatcher() *Watcher {
+	w := &Watcher{
+		update:      make(chan string),
+		watchVendor: false,
+	}
+	var err error
+	w.watcher, err = fsnotify.NewWatcher()
+	if err != nil {
+		log.Fatalf("Could not register watcher: %s", err)
+	}
+	w.watchFolders()
+	return w
+}
+// Watch listens file updates, and sends signal to
+// update channel when .go and .tmpl files are updated
+func (w *Watcher) Watch() {
+	eventSent := false
+	for {
+		select {
+		case event := <-w.watcher.Events:
+			// discard chmod events
+			if event.Op&fsnotify.Chmod != fsnotify.Chmod {
+				// test files do not need a rebuild
+				if isTestFile(event.Name) {
+					continue
+				}
+				if !isWatchedFileType(event.Name) {
+					continue
+				}
+				if eventSent {
+					continue
+				}
+				eventSent = true
+				// prevent consequent builds
+				go func() {
+					w.update <- event.Name
+					time.Sleep(watchDelta)
+					eventSent = false
+				}()
+			}
+		case err := <-w.watcher.Errors:
+			if err != nil {
+				log.Fatalf("Watcher error: %s", err)
+			}
+			return
+		}
+	}
+}
+func isTestFile(fileName string) bool {
+	return strings.HasSuffix(filepath.Base(fileName), "_test.go")
+}
+func isWatchedFileType(fileName string) bool {
+	ext := filepath.Ext(fileName)
+	return ext == ".go"
+}
+// Close closes the fsnotify watcher channel
+func (w *Watcher) Close() {
+	w.watcher.Close()
+	close(w.update)
+}
+// watchFolders recursively adds folders that will be watched against the changes,
+// starting from the working directory
+func (w *Watcher) watchFolders() {
+	wd, err := os.Getwd()
+	if err != nil {
+		log.Fatalf("Could not get root working directory: %s", err)
+	}
+	filepath.Walk(wd, func(path string, info os.FileInfo, err error) error {
+		// skip files
+		if info == nil {
+			log.Fatalf("wrong watcher package: %s", path)
+		}
+		if !info.IsDir() {
+			return nil
+		}
+		if !w.watchVendor {
+			// skip vendor directory
+			vendor := fmt.Sprintf("%s/vendor", wd)
+			if strings.HasPrefix(path, vendor) {
+				return filepath.SkipDir
+			}
+		}
+		// skip hidden folders
+		if len(path) > 1 && strings.HasPrefix(filepath.Base(path), ".") {
+			return filepath.SkipDir
+		}
+		w.addFolder(path)
+		return err
+	})
+}
+// addFolder adds given folder name to the watched folders, and starts
+// watching it for further changes
+func (w *Watcher) addFolder(name string) {
+	println("watch: " + name)
+	if err := w.watcher.Add(name); err != nil {
+		log.Fatalf("Could not watch folder: %s", err)
+	}
+}
+var routesMap = map[string]func(*app.RenderContext) app.UI{}
+func getSOPath(p string) string {
+	return "build/" + filepath.Base(filepath.Dir(p)) + ".so"
+}
+func getWasmPath(p string) string {
+	return "build/" + filepath.Base(filepath.Dir(p)) + ".wasm"
+}
+func build(path string) (string, error) {
+	soPath := getSOPath(path)
+	out, err := exec.Command("go", "build", "-buildmode=plugin", "-o", soPath, path).CombinedOutput()
+	if err != nil {
+		println(string(out))
+		println(err.Error())
+		return "", err
+	}
+	fmt.Printf("wrote: %s\n", soPath)
+	return soPath, nil
+}
+func buildWasm(path string) (string, error) {
+	wasmPath := getWasmPath(path)
+	cmd := exec.Command("go", "build", "-o", wasmPath, path)
+	cmd.Env = os.Environ()
+	cmd.Env = append(cmd.Env, "GOOS=js", "GOARCH=wasm")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		println(string(out))
+		println(err.Error())
+		return "", err
+	}
+	fmt.Printf("wrote: %s\n", wasmPath)
+	return wasmPath, nil
+}
+func getRoute(wd, p string) string {
+	basePath := filepath.Join(wd, "pages")
+	routePath := strings.Replace(p, basePath, "", 1)
+	routePath = strings.Replace(routePath, "/main.go", "", -1)
+	routePath = strings.Replace(routePath, "index", "", -1)
+	return routePath
+}
+func buildAll(wd string) {
+	basePath := filepath.Join(wd, "pages")
+	err := filepath.Walk(basePath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			fmt.Printf("prevent panic by handling failure accessing a path %q: %v\n", path, err)
+			return err
+		}
+		if !info.IsDir() {
+			fmt.Printf("route: %s\n", getRoute(wd, path))
+			soPath, err := build(path)
+			load(wd, path, soPath)
+			buildWasm(path)
+			if err != nil {
+				println("could not build")
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		fmt.Printf("error walking the path %q: %v\n", wd, err)
+		return
+	}
+}
+func load(wd, file, soPath string) {
+	routePath := getRoute(wd, file)
+	p, err := plugin.Open(soPath)
+	if err != nil {
+		panic(err)
+	}
+	renderFn, err := p.Lookup("Route")
+	if err != nil {
+		panic(err)
+	}
+	routesMap[routePath] = renderFn.(func(*app.RenderContext) app.UI)
+	// println(createPage(routesMap[routePath](app.NewRenderContext())).String())
+}
+func createPage(ui app.UI, wasmPath string) *bytes.Buffer {
+	page := bytes.NewBuffer(nil)
+	page.WriteString("<!DOCTYPE html>\n")
+	app.Html(
+		app.Head(
+			app.Title("Title"),
+			app.Meta("author", "pyros2097"),
+			app.Meta("description", "Description"),
+			app.Meta("keywords", ""),
+			app.Meta("theme-color", ""),
+			app.Meta("viewport", "width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0, viewport-fit=cover"),
+			app.Link("icon", "/assets/icon.png"),
+			app.Link("apple-touch-icon", "/assets/icon.png"),
+			app.Link("manifest", "manifest"),
+			app.Script(wasmExecJs(wasmPath)),
+		),
+		app.Body(ui),
+	).Html(page)
+	return page
+}
+func serve(wd string) {
+	assetsFileServer := http.FileServer(pkger.Dir("./assets"))
+	buildFileServer := http.FileServer(pkger.Dir("./build"))
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if render, ok := routesMap[r.URL.Path]; ok {
+			wasmPath := "/build/"
+			if r.URL.Path == "/" {
+				wasmPath += "index.wasm"
+			} else {
+				wasmPath += strings.ReplaceAll(r.URL.Path, "/", "") + ".wasm"
+			}
+			page := createPage(render(app.NewRenderContext()), wasmPath)
+			w.Header().Set("Content-Length", strconv.Itoa(page.Len()))
+			w.Header().Set("Content-Type", "text/html")
+			w.WriteHeader(http.StatusOK)
+			w.Write(page.Bytes())
+		} else if strings.Contains(r.URL.Path, "/build") {
+			r.URL.Path = strings.Replace(r.URL.Path, "/build", "", 1)
+			buildFileServer.ServeHTTP(w, r)
+		} else {
+			r.URL.Path = strings.Replace(r.URL.Path, "/assets", "", 1)
+			assetsFileServer.ServeHTTP(w, r)
+		}
+	})
+	log.Printf("Serving on HTTP port: 1234")
+	log.Fatal(http.ListenAndServe(":1234", nil))
+}
+func main() {
+	wd, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("could not get wd")
+		return
+	}
+	buildAll(wd)
+	watcher := MustRegisterWatcher()
+	go watcher.Watch()
+	go serve(wd)
+	for file := range watcher.update {
+		println("changed: " + file)
+		soPath, err := build(file)
+		if err != nil {
+			println("go build error: " + soPath)
+			continue
+		}
+		load(wd, file, soPath)
+		wasmPath, err := buildWasm(file)
+		if err != nil {
+			println("wasm build error: " + wasmPath)
+			continue
+		}
+	}
+}

component.go ADDED Viewed

@@ -0,0 +1,380 @@
+package app
+import (
+	"context"
+	"reflect"
+	"strings"
+	"github.com/pyros2097/wapp/errors"
+)
+// Composer is the interface that describes a customized, independent and
+// reusable UI element.
+//
+// Satisfying this interface is done by embedding app.Compo into a struct and
+// implementing the Render function.
+//
+// Example:
+//  type Hello struct {
+//      app.Compo
+//  }
+//
+//  func (c *Hello) Render() app.UI {
+//      return app.Text("hello")
+//  }
+type Composer interface {
+	UI
+	// Render returns the node tree that define how the component is desplayed.
+	Render() UI
+	// Update update the component appearance. It should be called when a field
+	// used to render the component has been modified.
+	Update()
+}
+var contextMap = map[int]*RenderContext{}
+var contextIndex = 0
+func getCurrentContext() *RenderContext {
+	return contextMap[contextIndex]
+}
+type RenderFunc func(ctx *RenderContext) UI
+func (r RenderFunc) Kind() Kind {
+	return FunctionalComponent
+}
+func (r RenderFunc) JSValue() Value {
+	c := getCurrentContext()
+	return c.root.JSValue()
+}
+func (r RenderFunc) Mounted() bool {
+	c := getCurrentContext()
+	return c.root != nil && c.root.Mounted() &&
+		r.self() != nil
+}
+func (r RenderFunc) Render() UI {
+	c := getCurrentContext()
+	c.index = 0
+	c.eindex = 0
+	println("render")
+	elems := FilterUIElems(r(c))
+	return elems[0]
+}
+func (r RenderFunc) Update() {
+	dispatch(func() {
+		if !r.Mounted() {
+			return
+		}
+		println("update")
+		if err := r.updateRoot(); err != nil {
+			panic(err)
+		}
+	})
+}
+func (r RenderFunc) name() string {
+	name := reflect.TypeOf(r.self()).String()
+	name = strings.ReplaceAll(name, "main.", "")
+	return name
+}
+func (r RenderFunc) self() UI {
+	c := getCurrentContext()
+	return c.this
+}
+func (r RenderFunc) setSelf(n UI) {
+	c := getCurrentContext()
+	if n != nil {
+		println("new context")
+		c := NewRenderContext()
+		c.this = n.(Composer)
+		return
+	}
+	c.this = nil
+}
+func (r RenderFunc) context() context.Context {
+	return nil
+}
+func (r RenderFunc) attributes() map[string]string {
+	return nil
+}
+func (r RenderFunc) eventHandlers() map[string]eventHandler {
+	return nil
+}
+func (r RenderFunc) parent() UI {
+	c := getCurrentContext()
+	return c.parentElem
+}
+func (r RenderFunc) setParent(p UI) {
+	c := getCurrentContext()
+	c.parentElem = p
+}
+func (r RenderFunc) children() []UI {
+	c := getCurrentContext()
+	return []UI{c.root}
+}
+func (r RenderFunc) mount() error {
+	c := getCurrentContext()
+	if r.Mounted() {
+		return errors.New("mounting component failed").
+			Tag("reason", "already mounted").
+			Tag("name", r.name()).
+			Tag("kind", r.Kind())
+	}
+	root := r.Render()
+	if err := mount(root); err != nil {
+		return errors.New("mounting component failed").
+			Tag("name", r.name()).
+			Tag("kind", r.Kind()).
+			Wrap(err)
+	}
+	root.setParent(c.this)
+	c.root = root
+	return nil
+}
+func (r RenderFunc) dismount() {
+	c := getCurrentContext()
+	for _, v := range c.effectsUnsub {
+		if v != nil {
+			v()
+		}
+	}
+	dismount(c.root)
+	delete(contextMap, c.contextMapIndex)
+	contextIndex--
+}
+func (r RenderFunc) update(n UI) error {
+	if r.self() == n || !r.Mounted() {
+		return nil
+	}
+	if r.Kind() != r.Kind() || n.name() != n.name() {
+		return errors.New("updating ui element failed").
+			Tag("replace", true).
+			Tag("reason", "different element types").
+			Tag("current-kind", r.Kind()).
+			Tag("current-name", r.name()).
+			Tag("updated-kind", n.Kind()).
+			Tag("updated-name", n.name())
+	}
+	aval := reflect.Indirect(reflect.ValueOf(r.self()))
+	bval := reflect.Indirect(reflect.ValueOf(n))
+	compotype := reflect.ValueOf(r).Elem().Type()
+	for i := 0; i < aval.NumField(); i++ {
+		a := aval.Field(i)
+		b := bval.Field(i)
+		if a.Type() == compotype {
+			continue
+		}
+		if !a.CanSet() {
+			continue
+		}
+		if !reflect.DeepEqual(a.Interface(), b.Interface()) {
+			a.Set(b)
+		}
+	}
+	return r.updateRoot()
+}
+func (r RenderFunc) updateRoot() error {
+	c := getCurrentContext()
+	a := c.root
+	println("updateRoot")
+	b := r.Render()
+	err := update(a, b)
+	if isErrReplace(err) {
+		err = r.replaceRoot(b)
+	}
+	if err != nil {
+		return errors.New("updating component failed").
+			Tag("kind", r.Kind()).
+			Tag("name", r.name()).
+			Wrap(err)
+	}
+	return nil
+}
+func (r RenderFunc) replaceRoot(n UI) error {
+	c := getCurrentContext()
+	old := c.root
+	new := n
+	if err := mount(new); err != nil {
+		return errors.New("replacing component root failed").
+			Tag("kind", r.Kind()).
+			Tag("name", r.name()).
+			Tag("root-kind", old.Kind()).
+			Tag("root-name", old.name()).
+			Tag("new-root-kind", new.Kind()).
+			Tag("new-root-name", new.name()).
+			Wrap(err)
+	}
+	var parent UI
+	for {
+		parent = r.parent()
+		if parent == nil || parent.Kind() == HTML {
+			break
+		}
+	}
+	if parent == nil {
+		return errors.New("replacing component root failed").
+			Tag("kind", r.Kind()).
+			Tag("name", r.name()).
+			Tag("reason", "coponent does not have html element parents")
+	}
+	c.root = new
+	new.setParent(r.self())
+	oldjs := old.JSValue()
+	newjs := n.JSValue()
+	parent.JSValue().Call("replaceChild", newjs, oldjs)
+	dismount(old)
+	return nil
+}
+type RenderContext struct {
+	contextMapIndex int
+	parentElem      UI
+	root            UI
+	this            Composer
+	index           int
+	values          map[int]interface{}
+	eindex          int
+	effects         map[int][]interface{}
+	effectsUnsub    map[int]func()
+}
+func NewRenderContext() *RenderContext {
+	c := &RenderContext{
+		contextMapIndex: contextIndex,
+		values:          map[int]interface{}{},
+		effects:         map[int][]interface{}{},
+		effectsUnsub:    map[int]func(){},
+	}
+	contextMap[contextIndex] = c
+	// contextIndex++
+	return c
+}
+func (c *RenderContext) UseState(initial interface{}) (func() interface{}, func(v interface{})) {
+	i := c.index
+	c.index++
+	if _, ok := c.values[i]; !ok {
+		c.values[i] = initial
+	}
+	return func() interface{} {
+			return c.values[i].(interface{})
+		}, func(v interface{}) {
+			c.values[i] = v
+			// special check so that the backend doesn't crash
+			if c.this != nil {
+				c.this.Update()
+			}
+		}
+}
+func (c *RenderContext) UseInt(initial int) (func() int, func(v int)) {
+	getState, setState := c.UseState(initial)
+	return func() int {
+			return getState().(int)
+		}, func(v int) {
+			setState(v)
+		}
+}
+func (c *RenderContext) UseEffect(f func() func(), deps ...interface{}) {
+	i := c.eindex
+	c.eindex++
+	if _, ok := c.effects[i]; !ok {
+		println("initial deps")
+		c.effects[i] = deps
+		c.effectsUnsub[i] = f()
+		return
+	}
+	hasChanged := false
+	for di, ndv := range deps {
+		odv := c.effects[i][di]
+		if odv != ndv {
+			c.effects[i] = deps
+			hasChanged = true
+			break
+		}
+	}
+	println("hasChanged", hasChanged)
+	if hasChanged {
+		f()
+	}
+}
+func (c *RenderContext) UseAtom(a *Atom) interface{} {
+	c.UseEffect(func() func() {
+		return a.Subscribe(func(v interface{}) {
+			c.this.Update()
+		})
+	})
+	return a.Get()
+}
+type Subscriber func(v interface{})
+type Atom struct {
+	value       interface{}
+	subscribers []Subscriber
+}
+func NewAtom(v interface{}) *Atom {
+	return &Atom{
+		value: v,
+	}
+}
+func (a *Atom) Subscribe(v Subscriber) func() {
+	a.subscribers = append(a.subscribers, v)
+	i := len(a.subscribers)
+	return func() {
+		a.subscribers = append(a.subscribers[:i], a.subscribers[i+1:]...)
+	}
+}
+func (a *Atom) Get() interface{} {
+	return a.value
+}
+func (a *Atom) Set(v interface{}) {
+	a.value = v
+	for _, s := range a.subscribers {
+		s(v)
+	}
+}

component_test.go ADDED Viewed

@@ -0,0 +1,277 @@
+package app
+// func TestCompoMountDismount(t *testing.T) {
+// 	testMountDismount(t, []mountTest{
+// 		{
+// 			scenario: "component",
+// 			node:     &hello{},
+// 		},
+// 	})
+// }
+// func TestCompoUpdate(t *testing.T) {
+// 	testUpdate(t, []updateTest{
+// 		{
+// 			scenario: "component is updated",
+// 			a:        &bar{Value: "rab"},
+// 			b:        &bar{Value: "bar"},
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: &bar{Value: "bar"},
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Text("bar"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario:   "component returns replace error when updated with a non component-element",
+// 			a:          &hello{},
+// 			b:          Text("hello"),
+// 			replaceErr: true,
+// 		},
+// 		{
+// 			scenario: "component is updated",
+// 			a:        &hello{},
+// 			b:        &hello{Greeting: "world"},
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: &hello{Greeting: "world"},
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: H1(),
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 0),
+// 					Expected: Text("hello, "),
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 1),
+// 					Expected: Text("world"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component is replaced by a text",
+// 			a: Div().Body(
+// 				&hello{},
+// 			),
+// 			b: Div().Body(
+// 				Text("hello"),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Text("hello"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component is replaced by an html element",
+// 			a: Div().Body(
+// 				&hello{},
+// 			),
+// 			b: Div().Body(
+// 				H2().Text("hello"),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: H2(),
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: Text("hello"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component is replaced by a raw html element",
+// 			a: Div().Body(
+// 				&hello{},
+// 			),
+// 			b: Div().Body(
+// 				Raw("<svg></svg>"),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Raw("<svg></svg>"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component is replaced by another component",
+// 			a: Div().Body(
+// 				&hello{},
+// 			),
+// 			b: Div().Body(
+// 				&bar{},
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: &bar{},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: Text(""),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component root is updated",
+// 			a: Div().Body(
+// 				&foo{Bar: "hello"},
+// 			),
+// 			b: Div().Body(
+// 				&foo{Bar: "goodbye"},
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: &foo{Bar: "goodbye"},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: &bar{Value: "goodbye"},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 0),
+// 					Expected: Text("goodbye"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component root is replaced by a component",
+// 			a: Div().Body(
+// 				&foo{},
+// 			),
+// 			b: Div().Body(
+// 				&foo{Bar: "test"},
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: &foo{Bar: "test"},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: &bar{Value: "test"},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 0),
+// 					Expected: Text("test"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "component root is replaced by a non-component",
+// 			a: Div().Body(
+// 				&foo{Bar: "test"},
+// 			),
+// 			b: Div().Body(
+// 				&foo{},
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: &foo{},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0),
+// 					Expected: Text("bar"),
+// 				},
+// 			},
+// 		},
+// 	})
+// }
+// type hello struct {
+// 	Compo
+// 	Greeting string
+// 	onNavURL string
+// }
+// func (h *hello) OnMount(Context) {
+// }
+// func (h *hello) OnNav(ctx Context, u *url.URL) {
+// 	h.onNavURL = u.String()
+// }
+// func (h *hello) OnDismount(Context) {
+// }
+// func (h *hello) Render() UI {
+// 	return Div().Body(
+// 		H1().Body(
+// 			Text("hello, "),
+// 			Text(h.Greeting),
+// 		),
+// 	)
+// }
+// type foo struct {
+// 	Compo
+// 	Bar string
+// }
+// func (f *foo) Render() UI {
+// 	return If(f.Bar != "",
+// 		&bar{Value: f.Bar},
+// 	).Else(
+// 		Text("bar"),
+// 	)
+// }
+// type bar struct {
+// 	Compo
+// 	Value    string
+// 	onNavURL string
+// }
+// func (b *bar) OnNav(ctx Context, u *url.URL) {
+// 	b.onNavURL = u.String()
+// }
+// func (b *bar) Render() UI {
+// 	return Text(b.Value)
+// }

concurrency.go ADDED Viewed

@@ -0,0 +1,15 @@
+package app
+var (
+	dispatch Dispatcher = Dispatch
+	uiChan              = make(chan func(), 512)
+)
+// Dispatcher is a function that executes the given function on the goroutine
+// dedicated to UI.
+type Dispatcher func(func())
+// Dispatch executes the given function on the UI goroutine.
+func Dispatch(f func()) {
+	uiChan <- f
+}

condition.go ADDED Viewed

@@ -0,0 +1,121 @@
+package app
+import (
+	"context"
+	"net/url"
+	"github.com/pyros2097/wapp/errors"
+)
+// Condition represents a control structure that displays nodes depending on a
+// given expression.
+type Condition interface {
+	UI
+	// ElseIf sets the condition with the given nodes if previous expressions
+	// were not met and given expression is true.
+	ElseIf(expr bool, elems ...UI) Condition
+	// Else sets the condition with the given UI elements if previous
+	// expressions were not met.
+	Else(elems ...UI) Condition
+}
+// If returns a condition that filters the given elements according to the given
+// expression.
+func If(expr bool, elems ...UI) Condition {
+	if !expr {
+		elems = nil
+	}
+	return condition{
+		body:      FilterUIElems(elems...),
+		satisfied: expr,
+	}
+}
+type condition struct {
+	body      []UI
+	satisfied bool
+}
+func (c condition) ElseIf(expr bool, elems ...UI) Condition {
+	if c.satisfied {
+		return c
+	}
+	if expr {
+		c.body = FilterUIElems(elems...)
+		c.satisfied = expr
+	}
+	return c
+}
+func (c condition) Else(elems ...UI) Condition {
+	return c.ElseIf(true, elems...)
+}
+func (c condition) Kind() Kind {
+	return Selector
+}
+func (c condition) JSValue() Value {
+	return nil
+}
+func (c condition) Mounted() bool {
+	return false
+}
+func (c condition) name() string {
+	return "if.else"
+}
+func (c condition) self() UI {
+	return c
+}
+func (c condition) setSelf(UI) {
+}
+func (c condition) context() context.Context {
+	return nil
+}
+func (c condition) attributes() map[string]string {
+	return nil
+}
+func (c condition) eventHandlers() map[string]eventHandler {
+	return nil
+}
+func (c condition) parent() UI {
+	return nil
+}
+func (c condition) setParent(UI) {
+}
+func (c condition) children() []UI {
+	return c.body
+}
+func (c condition) mount() error {
+	return errors.New("condition is not mountable").
+		Tag("name", c.name()).
+		Tag("kind", c.Kind())
+}
+func (c condition) dismount() {
+}
+func (c condition) update(UI) error {
+	return errors.New("condition cannot be updated").
+		Tag("name", c.name()).
+		Tag("kind", c.Kind())
+}
+func (c condition) onNav(*url.URL) {
+}

condition_test.go ADDED Viewed

@@ -0,0 +1,175 @@
+package app
+import "testing"
+func TestCondition(t *testing.T) {
+	testUpdate(t, []updateTest{
+		{
+			scenario: "if is interpreted",
+			a: Div().Body(
+				If(false,
+					H1(),
+				),
+			),
+			b: Div().Body(
+				If(true,
+					H1(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: H1(),
+				},
+			},
+		},
+		{
+			scenario: "if is not interpreted",
+			a: Div().Body(
+				If(true,
+					H1(),
+				),
+			),
+			b: Div().Body(
+				If(false,
+					H1(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: nil,
+				},
+			},
+		},
+		{
+			scenario: "else if is interpreted",
+			a: Div().Body(
+				If(true,
+					H1(),
+				).ElseIf(false,
+					H2(),
+				),
+			),
+			b: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(true,
+					H2(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: H2(),
+				},
+			},
+		},
+		{
+			scenario: "else if is not interpreted",
+			a: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(true,
+					H2(),
+				),
+			),
+			b: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(false,
+					H2(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: nil,
+				},
+			},
+		},
+		{
+			scenario: "else is interpreted",
+			a: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(true,
+					H2(),
+				).Else(
+					H3(),
+				),
+			),
+			b: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(false,
+					H2(),
+				).Else(
+					H3(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: H3(),
+				},
+			},
+		},
+		{
+			scenario: "else is not interpreted",
+			a: Div().Body(
+				If(false,
+					H1(),
+				).ElseIf(true,
+					H2(),
+				).Else(
+					H3(),
+				),
+			),
+			b: Div().Body(
+				If(true,
+					H1(),
+				).ElseIf(false,
+					H2(),
+				).Else(
+					H3(),
+				),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: H1(),
+				},
+			},
+		},
+	})
+}

context.go ADDED Viewed

@@ -0,0 +1,20 @@
+package app
+import "context"
+// Context represents a context that is tied to a UI element. It is canceled
+// when the element is dismounted.
+//
+// It implements the context.Context interface.
+//  https://golang.org/pkg/context/#Context
+type Context struct {
+	context.Context
+	// The UI element tied to the context.
+	Src UI
+	// The JavaScript value of the element tied to the context. This is a
+	// shorthand for:
+	//  ctx.Src.JSValue()
+	JSSrc Value
+}

element.go ADDED Viewed

@@ -0,0 +1,456 @@
+package app
+import (
+	"context"
+	"io"
+	"github.com/pyros2097/wapp/errors"
+)
+type elem struct {
+	attrs       map[string]string
+	body        []UI
+	ctx         context.Context
+	ctxCancel   func()
+	events      map[string]eventHandler
+	jsvalue     Value
+	parentElem  UI
+	selfClosing bool
+	tag         string
+	this        UI
+}
+func (e *elem) Kind() Kind {
+	return HTML
+}
+func (e *elem) JSValue() Value {
+	return e.jsvalue
+}
+func (e *elem) Mounted() bool {
+	return e.ctx != nil && e.ctx.Err() == nil &&
+		e.self() != nil &&
+		e.jsvalue != nil
+}
+func (e *elem) name() string {
+	return e.tag
+}
+func (e *elem) self() UI {
+	return e.this
+}
+func (e *elem) setSelf(n UI) {
+	e.this = n
+}
+func (e *elem) context() context.Context {
+	return e.ctx
+}
+func (e *elem) attributes() map[string]string {
+	return e.attrs
+}
+func (e *elem) eventHandlers() map[string]eventHandler {
+	return e.events
+}
+func (e *elem) parent() UI {
+	return e.parentElem
+}
+func (e *elem) setParent(p UI) {
+	e.parentElem = p
+}
+func (e *elem) children() []UI {
+	return e.body
+}
+func (e *elem) mount() error {
+	if e.Mounted() {
+		return errors.New("mounting ui element failed").
+			Tag("reason", "already mounted").
+			Tag("name", e.name()).
+			Tag("kind", e.Kind())
+	}
+	e.ctx, e.ctxCancel = context.WithCancel(context.Background())
+	v := Window().Get("document").Call("createElement", e.tag)
+	if !v.Truthy() {
+		return errors.New("mounting ui element failed").
+			Tag("reason", "create javascript node returned nil").
+			Tag("name", e.name()).
+			Tag("kind", e.Kind())
+	}
+	e.jsvalue = v
+	for k, v := range e.attrs {
+		e.setJsAttr(k, v)
+	}
+	for k, v := range e.events {
+		e.setJsEventHandler(k, v)
+	}
+	for _, c := range e.children() {
+		if err := e.appendChild(c, true); err != nil {
+			return errors.New("mounting ui element failed").
+				Tag("name", e.name()).
+				Tag("kind", e.Kind()).
+				Wrap(err)
+		}
+	}
+	return nil
+}
+func (e *elem) dismount() {
+	for _, c := range e.children() {
+		dismount(c)
+	}
+	for k, v := range e.events {
+		e.delJsEventHandler(k, v)
+	}
+	e.ctxCancel()
+	e.jsvalue = nil
+}
+func (e *elem) update(n UI) error {
+	if !e.Mounted() {
+		return nil
+	}
+	if n.Kind() != e.Kind() || n.name() != e.name() {
+		return errors.New("updating ui element failed").
+			Tag("replace", true).
+			Tag("reason", "different element types").
+			Tag("current-kind", e.Kind()).
+			Tag("current-name", e.name()).
+			Tag("updated-kind", n.Kind()).
+			Tag("updated-name", n.name())
+	}
+	e.updateAttrs(n.attributes())
+	e.updateEventHandler(n.eventHandlers())
+	achildren := e.children()
+	bchildren := n.children()
+	i := 0
+	// Update children:
+	for len(achildren) != 0 && len(bchildren) != 0 {
+		a := achildren[0]
+		b := bchildren[0]
+		err := update(a, b)
+		if isErrReplace(err) {
+			err = e.replaceChildAt(i, b)
+		}
+		if err != nil {
+			return errors.New("updating ui element failed").
+				Tag("kind", e.Kind()).
+				Tag("name", e.name()).
+				Wrap(err)
+		}
+		achildren = achildren[1:]
+		bchildren = bchildren[1:]
+		i++
+	}
+	// Remove children:
+	for len(achildren) != 0 {
+		if err := e.removeChildAt(i); err != nil {
+			return errors.New("updating ui element failed").
+				Tag("kind", e.Kind()).
+				Tag("name", e.name()).
+				Wrap(err)
+		}
+		achildren = achildren[1:]
+	}
+	// Add children:
+	for len(bchildren) != 0 {
+		c := bchildren[0]
+		if err := e.appendChild(c, false); err != nil {
+			return errors.New("updating ui element failed").
+				Tag("kind", e.Kind()).
+				Tag("name", e.name()).
+				Wrap(err)
+		}
+		bchildren = bchildren[1:]
+	}
+	return nil
+}
+func (e *elem) appendChild(c UI, onlyJsValue bool) error {
+	if err := mount(c); err != nil {
+		return errors.New("appending child failed").
+			Tag("name", e.name()).
+			Tag("kind", e.Kind()).
+			Tag("child-name", c.name()).
+			Tag("child-kind", c.Kind()).
+			Wrap(err)
+	}
+	if !onlyJsValue {
+		e.body = append(e.body, c)
+	}
+	c.setParent(e.self())
+	e.JSValue().Call("appendChild", c)
+	return nil
+}
+func (e *elem) replaceChildAt(idx int, new UI) error {
+	old := e.body[idx]
+	if err := mount(new); err != nil {
+		return errors.New("replacing child failed").
+			Tag("name", e.name()).
+			Tag("kind", e.Kind()).
+			Tag("index", idx).
+			Tag("old-name", old.name()).
+			Tag("old-kind", old.Kind()).
+			Tag("new-name", new.name()).
+			Tag("new-kind", new.Kind()).
+			Wrap(err)
+	}
+	e.body[idx] = new
+	new.setParent(e.self())
+	e.JSValue().Call("replaceChild", new, old)
+	dismount(old)
+	return nil
+}
+func (e *elem) removeChildAt(idx int) error {
+	body := e.body
+	if idx < 0 || idx >= len(body) {
+		return errors.New("removing child failed").
+			Tag("reason", "index out of range").
+			Tag("index", idx).
+			Tag("name", e.name()).
+			Tag("kind", e.Kind())
+	}
+	c := body[idx]
+	copy(body[idx:], body[idx+1:])
+	body[len(body)-1] = nil
+	body = body[:len(body)-1]
+	e.body = body
+	e.JSValue().Call("removeChild", c)
+	dismount(c)
+	return nil
+}
+func (e *elem) updateAttrs(attrs map[string]string) {
+	for k := range e.attrs {
+		if _, exists := attrs[k]; !exists {
+			e.delAttr(k)
+		}
+	}
+	if e.attrs == nil && len(attrs) != 0 {
+		e.attrs = make(map[string]string, len(attrs))
+	}
+	for k, v := range attrs {
+		if curval, exists := e.attrs[k]; !exists || curval != v {
+			e.attrs[k] = v
+			e.setJsAttr(k, v)
+		}
+	}
+}
+func (e *elem) setAttr(k string, v interface{}) {
+	if e.attrs == nil {
+		e.attrs = make(map[string]string)
+	}
+	switch k {
+	case "style", "allow":
+		s := e.attrs[k] + toString(v) + ";"
+		e.attrs[k] = s
+		return
+	case "class":
+		s := e.attrs[k]
+		if s != "" {
+			s += " "
+		}
+		s += toString(v)
+		e.attrs[k] = s
+		return
+	}
+	switch v := v.(type) {
+	case bool:
+		if !v {
+			delete(e.attrs, k)
+			return
+		}
+		e.attrs[k] = ""
+	default:
+		e.attrs[k] = toString(v)
+	}
+}
+func (e *elem) setJsAttr(k, v string) {
+	e.JSValue().Call("setAttribute", k, v)
+}
+func (e *elem) delAttr(k string) {
+	e.JSValue().Call("removeAttribute", k)
+	delete(e.attrs, k)
+}
+func (e *elem) updateEventHandler(handlers map[string]eventHandler) {
+	for k, current := range e.events {
+		if _, exists := handlers[k]; !exists {
+			e.delJsEventHandler(k, current)
+		}
+	}
+	if e.events == nil && len(handlers) != 0 {
+		e.events = make(map[string]eventHandler, len(handlers))
+	}
+	for k, new := range handlers {
+		if current, exists := e.events[k]; !current.equal(new) {
+			if exists {
+				e.delJsEventHandler(k, current)
+			}
+			e.events[k] = new
+			e.setJsEventHandler(k, new)
+		}
+	}
+}
+func (e *elem) setEventHandler(k string, h EventHandler) {
+	if e.events == nil {
+		e.events = make(map[string]eventHandler)
+	}
+	e.events[k] = eventHandler{
+		event: k,
+		value: h,
+	}
+}
+func (e *elem) setJsEventHandler(k string, h eventHandler) {
+	jshandler := makeJsEventHandler(e.self(), h.value)
+	h.jsvalue = jshandler
+	e.events[k] = h
+	e.JSValue().Call("addEventListener", k, jshandler)
+}
+func (e *elem) delJsEventHandler(k string, h eventHandler) {
+	e.JSValue().Call("removeEventListener", k, h.jsvalue)
+	h.jsvalue.Release()
+	delete(e.events, k)
+}
+func (e *elem) setBody(body ...UI) {
+	if e.selfClosing {
+		panic(errors.New("setting html element body failed").
+			Tag("reason", "self closing element can't have children").
+			Tag("name", e.name()),
+		)
+	}
+	e.body = FilterUIElems(body...)
+}
+func (e *elem) Html(w io.Writer) {
+	e.HtmlWithIndent(w, 0)
+}
+func (e *elem) HtmlWithIndent(w io.Writer, indent int) {
+	writeIndent(w, indent)
+	w.Write(stob("<"))
+	w.Write(stob(e.tag))
+	for k, v := range e.attrs {
+		w.Write(stob(" "))
+		w.Write(stob(k))
+		if v != "" {
+			w.Write(stob(`="`))
+			w.Write(stob(v))
+			w.Write(stob(`"`))
+		}
+	}
+	w.Write(stob(">"))
+	if e.selfClosing {
+		return
+	}
+	for _, c := range e.body {
+		w.Write(ln())
+		c.(WritableNode).HtmlWithIndent(w, indent+1)
+	}
+	if len(e.body) != 0 {
+		w.Write(ln())
+		writeIndent(w, indent)
+	}
+	w.Write(stob("</"))
+	w.Write(stob(e.tag))
+	w.Write(stob(">"))
+}
+func (e *elem) ID(v string) *elem {
+	e.setAttr("id", v)
+	return e
+}
+func (e *elem) Style(k, v string) *elem {
+	e.setAttr("style", k+":"+v)
+	return e
+}
+func (e *elem) OnBlur(h EventHandler) *elem {
+	e.setEventHandler("blur", h)
+	return e
+}
+func (e *elem) OnChange(h EventHandler) *elem {
+	e.setEventHandler("change", h)
+	return e
+}
+func (e *elem) OnClick(h EventHandler) *elem {
+	e.setEventHandler("click", h)
+	return e
+}
+func (e *elem) OnFocus(h EventHandler) *elem {
+	e.setEventHandler("focus", h)
+	return e
+}
+func (e *elem) OnInput(h EventHandler) *elem {
+	e.setEventHandler("input", h)
+	return e
+}

element_test.go ADDED Viewed

@@ -0,0 +1,367 @@
+package app
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+func TestElemSetAttr(t *testing.T) {
+	utests := []struct {
+		scenario       string
+		key            string
+		value          interface{}
+		explectedValue string
+		valueNotSet    bool
+	}{
+		{
+			scenario:       "string",
+			key:            "title",
+			value:          "test",
+			explectedValue: "test",
+		},
+		{
+			scenario:       "int",
+			key:            "max",
+			value:          42,
+			explectedValue: "42",
+		},
+		{
+			scenario:       "bool true",
+			key:            "hidden",
+			value:          true,
+			explectedValue: "",
+		},
+		{
+			scenario:    "bool false",
+			key:         "hidden",
+			value:       false,
+			valueNotSet: true,
+		},
+		{
+			scenario:       "style",
+			key:            "style",
+			value:          "margin:42",
+			explectedValue: "margin:42;",
+		},
+		{
+			scenario:       "set successive styles",
+			key:            "style",
+			value:          "padding:42",
+			explectedValue: "margin:42;padding:42;",
+		},
+		{
+			scenario:       "class",
+			key:            "class",
+			value:          "hello",
+			explectedValue: "hello",
+		},
+		{
+			scenario:       "set successive classes",
+			key:            "class",
+			value:          "world",
+			explectedValue: "hello world",
+		},
+	}
+	e := &elem{}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			e.setAttr(u.key, u.value)
+			v, exists := e.attrs[u.key]
+			require.Equal(t, u.explectedValue, v)
+			require.Equal(t, u.valueNotSet, !exists)
+		})
+	}
+}
+func TestElemUpdateAttrs(t *testing.T) {
+	utests := []struct {
+		scenario string
+		current  map[string]string
+		incoming map[string]string
+	}{
+		{
+			scenario: "attributes are removed",
+			current: map[string]string{
+				"foo":   "bar",
+				"hello": "world",
+			},
+			incoming: nil,
+		},
+		{
+			scenario: "attributes are added",
+			current:  nil,
+			incoming: map[string]string{
+				"foo":   "bar",
+				"hello": "world",
+			},
+		},
+		{
+			scenario: "attributes are updated",
+			current: map[string]string{
+				"foo":   "bar",
+				"hello": "world",
+			},
+			incoming: map[string]string{
+				"foo":   "boo",
+				"hello": "there",
+			},
+		},
+		{
+			scenario: "attributes are synced",
+			current: map[string]string{
+				"foo":   "bar",
+				"hello": "world",
+			},
+			incoming: map[string]string{
+				"foo":     "boo",
+				"goodbye": "world",
+			},
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			testSkipNonWasm(t)
+			n := Div().(*htmlDiv)
+			err := mount(n)
+			require.NoError(t, err)
+			defer dismount(n)
+			n.attrs = u.current
+			n.updateAttrs(u.incoming)
+			if len(u.incoming) == 0 {
+				require.Empty(t, n.attributes())
+				return
+			}
+			require.Equal(t, u.incoming, n.attributes())
+		})
+	}
+}
+func TestElemSetEventHandler(t *testing.T) {
+	e := &elem{}
+	h := func(Context, Event) {}
+	e.setEventHandler("click", h)
+	expectedHandler := eventHandler{
+		event: "click",
+		value: h,
+	}
+	registeredHandler := e.events["click"]
+	require.True(t, expectedHandler.equal(registeredHandler))
+}
+func TestElemUpdateEventHandlers(t *testing.T) {
+	utests := []struct {
+		scenario string
+		current  EventHandler
+		incoming EventHandler
+	}{
+		{
+			scenario: "handler is removed",
+			current:  func(Context, Event) {},
+			incoming: nil,
+		},
+		{
+			scenario: "handler is added",
+			current:  nil,
+			incoming: func(Context, Event) {},
+		},
+		{
+			scenario: "handler is updated",
+			current:  func(Context, Event) {},
+			incoming: func(Context, Event) {},
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			testSkipNonWasm(t)
+			var current map[string]eventHandler
+			var incoming map[string]eventHandler
+			if u.current != nil {
+				current = map[string]eventHandler{
+					"click": {
+						event: "click",
+						value: u.current,
+					},
+				}
+			}
+			if u.incoming != nil {
+				incoming = map[string]eventHandler{
+					"click": {
+						event: "click",
+						value: u.incoming,
+					},
+				}
+			}
+			n := Div().(*htmlDiv)
+			n.events = current
+			err := mount(n)
+			require.NoError(t, err)
+			defer dismount(n)
+			n.updateEventHandler(incoming)
+			if len(incoming) == 0 {
+				require.Empty(t, n.attributes())
+				return
+			}
+			h := n.eventHandlers()["click"]
+			require.True(t, h.equal(incoming["click"]))
+		})
+	}
+}
+func TestElemMountDismount(t *testing.T) {
+	testMountDismount(t, []mountTest{
+		{
+			scenario: "html element",
+			node: Div().
+				Class("hello").
+				OnClick(func(Context, Event) {}),
+		},
+	})
+}
+// func TestElemUpdate(t *testing.T) {
+// 	testUpdate(t, []updateTest{
+// 		{
+// 			scenario:   "html element returns replace error when updated with a non html-element",
+// 			a:          Div(),
+// 			b:          Text("hello"),
+// 			replaceErr: true,
+// 		},
+// 		{
+// 			scenario: "html element attributes are updated",
+// 			a: Div().
+// 				ID("max").
+// 				Class("foo").
+// 				AccessKey("test"),
+// 			b: Div().
+// 				ID("max").
+// 				Class("bar").
+// 				Lang("fr"),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Expected: Div().
+// 						ID("max").
+// 						Class("bar").
+// 						Lang("fr"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "html element event handlers are updated",
+// 			a: Div().
+// 				OnClick(func(Context, Event) {}).
+// 				OnBlur(func(Context, Event) {}),
+// 			b: Div().
+// 				OnClick(func(Context, Event) {}).
+// 				OnChange(func(Context, Event) {}),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Expected: Div().
+// 						OnClick(nil).
+// 						OnChange(nil),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "html element is replaced by a text",
+// 			a: Div().Body(
+// 				H2().Text("hello"),
+// 			),
+// 			b: Div().Body(
+// 				Text("hello"),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Text("hello"),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "html element is replaced by a component",
+// 			a: Div().Body(
+// 				H2().Text("hello"),
+// 			),
+// 			b: Div().Body(
+// 				&hello{},
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: &hello{},
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 0),
+// 					Expected: H1(),
+// 				},
+// 				{
+// 					Path:     TestPath(0, 0, 0, 0),
+// 					Expected: Text("hello, "),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "html element is replaced by another html element",
+// 			a: Div().Body(
+// 				H2(),
+// 			),
+// 			b: Div().Body(
+// 				H1(),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: H1(),
+// 				},
+// 			},
+// 		},
+// 		{
+// 			scenario: "html element is replaced by raw html element",
+// 			a: Div().Body(
+// 				H2().Text("hello"),
+// 			),
+// 			b: Div().Body(
+// 				Raw("<svg></svg>"),
+// 			),
+// 			matches: []TestUIDescriptor{
+// 				{
+// 					Path:     TestPath(),
+// 					Expected: Div(),
+// 				},
+// 				{
+// 					Path:     TestPath(0),
+// 					Expected: Raw("<svg></svg>"),
+// 				},
+// 			},
+// 		},
+// 	})
+// }

errors/README.md ADDED Viewed

@@ -0,0 +1,17 @@
+# errors
+Package errors implements functions to manipulate errors.
+Errors created are taggable and wrappable.
+```go
+errWithTags := errors.New("an error with tags").
+    Tag("a", 42).
+    Tag("b", 21)
+errWithWrap := errors.New("error").
+    Tag("a", 42).
+    Wrap(errors.New("wrapped error"))
+```
+The package mirrors https:golang.org/pkg/errors package.

errors/errors.go ADDED Viewed

@@ -0,0 +1,208 @@
+// Package errors implements functions to manipulate errors.
+//
+// Errors created are taggable and wrappable.
+//
+//   errWithTags := errors.New("an error with tags").
+//       Tag("a", 42).
+// 	     Tag("b", 21)
+//
+//   errWithWrap := errors.New("error").
+//       Tag("a", 42).
+// 	     Wrap(errors.New("wrapped error"))
+//
+// The package mirrors https://golang.org/pkg/errors package.
+package errors
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"unsafe"
+)
+// As is documented at https://golang.org/pkg/errors/#As.
+func As(err error, target interface{}) bool {
+	return errors.As(err, target)
+}
+// Is is documented at https://golang.org/pkg/errors/#Is.
+func Is(err, target error) bool {
+	return errors.Is(err, target)
+}
+// Unwrap is documented at https://golang.org/pkg/errors/#Unwrap.
+func Unwrap(err error) error {
+	return errors.Unwrap(err)
+}
+// Tag retrieves the value of the tag named by the key. If the tag exists,
+// its value (which may be empty) is returned and the boolean is true. Otherwise
+// the returned value will be empty and the boolean will be false.
+func Tag(err error, k string) (string, bool) {
+	ierr, ok := err.(Error)
+	if !ok {
+		return "", false
+	}
+	return ierr.Lookup(k)
+}
+// New returns an error with the given description that can be tagged.
+func New(v string) Error {
+	return Error{
+		description: v,
+	}
+}
+// Newf returns an error with the given formatted description that can be
+// tagged.
+func Newf(format string, v ...interface{}) Error {
+	return New(fmt.Sprintf(format, v...))
+}
+// Error is an error implementation that supports tagging and wrapping.
+type Error struct {
+	description string
+	tags        []tag
+	maxKeyLen   int
+	wrap        error
+}
+// Tag sets the named tag with the given value.
+func (e Error) Tag(k string, v interface{}) Error {
+	if e.tags == nil {
+		e.tags = make([]tag, 0, 8)
+	}
+	if l := len(k); l > e.maxKeyLen {
+		e.maxKeyLen = l
+	}
+	switch v := v.(type) {
+	case string:
+		e.tags = append(e.tags, tag{key: k, value: v})
+	default:
+		e.tags = append(e.tags, tag{key: k, value: fmt.Sprintf("%+v", v)})
+	}
+	return e
+}
+// Lookup retrieves the value of the tag named by the key. If the tag exists,
+// its value (which may be empty) is returned and the boolean is true. Otherwise
+// the returned value will be empty and the boolean will be false.
+func (e Error) Lookup(tag string) (string, bool) {
+	for _, t := range e.tags {
+		if t.key == tag {
+			return t.value, true
+		}
+	}
+	return "", false
+}
+// Wrap wraps the given error. Nil errors are ingnored.
+func (e Error) Wrap(err error) Error {
+	if err == nil {
+		return e
+	}
+	if e.maxKeyLen < 5 {
+		e.maxKeyLen = 5
+	}
+	if e.wrap == nil {
+		e.wrap = err
+		return e
+	}
+	description := ""
+	if perr, ok := err.(Error); ok {
+		description = perr.description
+	} else {
+		description = err.Error()
+	}
+	e.wrap = New(description).Wrap(e.wrap)
+	return e
+}
+// Unwrap unwraps the given error.
+func (e Error) Unwrap() error {
+	return e.wrap
+}
+// Is reports if the target matches the error or its wrapped values.
+func (e Error) Is(target error) bool {
+	o, ok := target.(Error)
+	if !ok {
+		return false
+	}
+	return e.description == o.description &&
+		reflect.DeepEqual(e.tags, o.tags)
+}
+func (e Error) Error() string {
+	w := bytes.NewBuffer(make([]byte, 0, len(e.description)+len(e.tags)*(e.maxKeyLen+11)))
+	e.format(w, 0)
+	return bytesToString(w.Bytes())
+}
+func (e Error) format(w *bytes.Buffer, indent int) {
+	w.WriteString(e.description)
+	if e.wrap != nil || len(e.tags) != 0 {
+		w.WriteByte(':')
+	}
+	tags := e.tags
+	sort.Slice(tags, func(a, b int) bool {
+		return strings.Compare(tags[a].key, tags[b].key) < 0
+	})
+	for _, t := range e.tags {
+		k := t.key
+		v := t.value
+		w.WriteByte('\n')
+		e.indent(w, indent+4)
+		w.WriteString(k)
+		w.WriteByte(':')
+		e.indent(w, e.maxKeyLen-len(k)+1)
+		w.WriteString(v)
+	}
+	if e.wrap == nil {
+		return
+	}
+	w.WriteByte('\n')
+	e.indent(w, indent+4)
+	w.WriteString("error")
+	w.WriteByte(':')
+	e.indent(w, e.maxKeyLen-5+1)
+	if err, ok := e.wrap.(Error); ok {
+		err.format(w, indent+4)
+		return
+	}
+	w.WriteString(e.wrap.Error())
+}
+func (e Error) indent(w *bytes.Buffer, n int) {
+	for i := 0; i < n; i++ {
+		w.WriteByte(' ')
+	}
+}
+type tag struct {
+	key   string
+	value string
+}
+func bytesToString(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}

errors/errors_test.go ADDED Viewed

@@ -0,0 +1,153 @@
+package errors
+import (
+	"errors"
+	"testing"
+	"time"
+	"github.com/stretchr/testify/require"
+)
+func TestError(t *testing.T) {
+	err := New("a simple error")
+	t.Log(err)
+}
+func TestErrorWithTags(t *testing.T) {
+	err := New("an error with tags").
+		Tag("string", "hello world").
+		Tag("go-stringer", goStringer{}).
+		Tag("duration", time.Duration(3600000000)).
+		Tag("int", 42).
+		Tag("int8", int8(8)).
+		Tag("int16", int16(16)).
+		Tag("int32", int32(32)).
+		Tag("int64", int64(64)).
+		Tag("uint", uint(42)).
+		Tag("uint8", uint8(8)).
+		Tag("uint16", uint16(16)).
+		Tag("uint32", uint32(32)).
+		Tag("uint64", uint64(64)).
+		Tag("float32", float32(32.42)).
+		Tag("float64", float64(64.42)).
+		Tag("slice", []string{"hello", "world"})
+	t.Log("\n", err)
+}
+func TestErrorWithWrap(t *testing.T) {
+	b := New("b").Wrap(errors.New("c"))
+	a := New("a").
+		Wrap(b).
+		Wrap(nil)
+	require.True(t, b.Is(a.wrap))
+	d := New("d").
+		Wrap(a).
+		Wrap(b).
+		Wrap(errors.New("f"))
+	t.Log("\n", d)
+}
+func TestErrorWithTagsAndWrap(t *testing.T) {
+	err := New("an error with tags").
+		Tag("uint64", uint64(64)).
+		Tag("float64", float64(64.42)).
+		Tag("slice", []string{"hello", "world"}).
+		Wrap(errors.New("another error"))
+	t.Log("\n", err)
+}
+func TestLookup(t *testing.T) {
+	err := New("error").Tag("foo", 42)
+	v, found := err.Lookup("foo")
+	require.True(t, found)
+	require.Equal(t, "42", v)
+	v, found = err.Lookup("bar")
+	require.False(t, found)
+	require.Empty(t, v)
+}
+func TestErrorUwrap(t *testing.T) {
+	a := New("a").Tag("wrap", true)
+	b := New("b").Wrap(a)
+	err := b.Unwrap()
+	require.Equal(t, a, err)
+	err = Unwrap(b)
+	require.Equal(t, a, err)
+}
+func TestAs(t *testing.T) {
+	a := New("a").Tag("wrap", true)
+	b := New("b").Wrap(a)
+	c := New("c").Wrap(b)
+	d := New("d")
+	require.True(t, As(c, &a))
+	require.True(t, As(c, &d))
+}
+func TestIs(t *testing.T) {
+	a := New("a").Tag("wrap", true)
+	b := New("b").Wrap(a)
+	c := New("c").Wrap(b)
+	d := New("d")
+	e := errors.New("e")
+	require.True(t, Is(c, a))
+	require.False(t, Is(c, d))
+	require.False(t, Is(d, e))
+}
+func TestTag(t *testing.T) {
+	a := errors.New("a")
+	v, isTagged := Tag(a, "test")
+	require.Empty(t, v)
+	require.False(t, isTagged)
+	b := New("b").Tag("test", "true")
+	v, isTagged = Tag(b, "test")
+	require.Equal(t, "true", v)
+	require.True(t, isTagged)
+}
+func TestNewf(t *testing.T) {
+	err := Newf("hello %q", "world")
+	t.Log(err)
+}
+type goStringer struct{}
+func (s goStringer) GoString() string {
+	return "go stringer !"
+}
+func BenchmarkNew(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		New("an error with tags").
+			Tag("string", "hello world").
+			Tag("int8", int8(8)).
+			Tag("int16", int16(16)).
+			Tag("int32", int32(32)).
+			Tag("int64", int64(64))
+	}
+}
+func BenchmarkError(b *testing.B) {
+	var s string
+	for n := 0; n < b.N; n++ {
+		s = New("an error with tags").
+			Tag("string", "hello world").
+			Tag("int8", int8(8)).
+			Tag("int16", int16(16)).
+			Tag("int32", int32(32)).
+			Tag("int64", int64(64)).
+			Error()
+	}
+	b.Log(s)
+}

go.mod ADDED Viewed

@@ -0,0 +1,12 @@
+module github.com/pyros2097/wapp
+go 1.15
+require (
+	github.com/fsnotify/fsnotify v1.4.7 // indirect
+	github.com/markbates/pkger v0.17.1
+	github.com/stretchr/testify v1.5.1
+	golang.org/x/sys v0.0.0-20201112073958-5cba982894dd // indirect
+	gopkg.in/fsnotify.v1 v1.4.7
+	gopkg.in/yaml.v2 v2.2.8 // indirect
+)

go.sum ADDED Viewed

@@ -0,0 +1,31 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/gobuffalo/here v0.6.0 h1:hYrd0a6gDmWxBM4TnrGw8mQg24iSVoIkHEk7FodQcBI=
+github.com/gobuffalo/here v0.6.0/go.mod h1:wAG085dHOYqUpf+Ap+WOdrPTp5IYcDAs/x7PLa8Y5fM=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/markbates/pkger v0.17.1 h1:/MKEtWqtc0mZvu9OinB9UzVN9iYCwLWuyUv4Bw+PCno=
+github.com/markbates/pkger v0.17.1/go.mod h1:0JoVlrol20BSywW79rN3kdFFsE5xYM+rSCQDXbLhiuI=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY=
+golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

html.go ADDED Viewed

@@ -0,0 +1,65 @@
+package app
+func Html(elems ...UI) *elem {
+	return &elem{tag: "html", body: elems}
+}
+func Head(elems ...UI) *elem {
+	basic := []UI{
+		&elem{tag: "meta", selfClosing: true, attrs: map[string]string{"charset": "UTF-8"}},
+		&elem{tag: "meta", selfClosing: true, attrs: map[string]string{"http-equiv": "Content-Type", "content": "text/html;charset=utf-8"}},
+		&elem{tag: "meta", selfClosing: true, attrs: map[string]string{"http-equiv": "encoding", "content": "utf-8"}},
+	}
+	return &elem{tag: "head", body: append(basic, elems...)}
+}
+func Body(elems ...UI) *elem {
+	return &elem{tag: "head", body: elems}
+}
+func Title(v string) *elem {
+	return &elem{tag: "title", body: []UI{Text(v)}}
+}
+func Meta(name, content string) *elem {
+	e := &elem{
+		tag:         "meta",
+		selfClosing: true,
+	}
+	e.setAttr("name", name)
+	e.setAttr("content", content)
+	return e
+}
+func Link(rel, href string) *elem {
+	e := &elem{
+		tag:         "link",
+		selfClosing: true,
+	}
+	e.setAttr("rel", rel)
+	e.setAttr("href", href)
+	return e
+}
+func Script(str string) *elem {
+	return &elem{
+		tag:  "script",
+		body: []UI{Text(str)},
+	}
+}
+func Div(elems ...UI) *elem {
+	return &elem{tag: "div", body: elems}
+}
+func Row(elems ...UI) *elem {
+	return &elem{tag: "div", body: elems, attrs: map[string]string{
+		"style": "display: flex;flex: 1;flex-direction: row;align-items: center;justify-content: center;",
+	}}
+}
+func Col(elems ...UI) *elem {
+	return &elem{tag: "div", body: elems, attrs: map[string]string{
+		"style": "display: flex;flex: 1;flex-direction: column;align-items: center;justify-content: center;",
+	}}
+}

js.go ADDED Viewed

@@ -0,0 +1,224 @@
+package app
+import "net/url"
+// Type represents the JavaScript type of a Value.
+type Type int
+// Constants that enumerates the JavaScript types.
+const (
+	TypeUndefined Type = iota
+	TypeNull
+	TypeBoolean
+	TypeNumber
+	TypeString
+	TypeSymbol
+	TypeObject
+	TypeFunction
+)
+// Wrapper is implemented by types that are backed by a JavaScript value.
+type Wrapper interface {
+	JSValue() Value
+}
+// Value is the interface that represents a JavaScript value. On wasm
+// architecture, it wraps the Value from https://golang.org/pkg/syscall/js/
+// package.
+type Value interface {
+	// Bool returns the value v as a bool. It panics if v is not a JavaScript
+	// boolean.
+	Bool() bool
+	// Call does a JavaScript call to the method m of value v with the given
+	// arguments. It panics if v has no method m. The arguments get mapped to
+	// JavaScript values according to the ValueOf function.
+	Call(m string, args ...interface{}) Value
+	// Float returns the value v as a float64. It panics if v is not a
+	// JavaScript number.
+	Float() float64
+	// Get returns the JavaScript property p of value v. It panics if v is not a
+	// JavaScript object.
+	Get(p string) Value
+	// Index returns JavaScript index i of value v. It panics if v is not a
+	// JavaScript object.
+	Index(i int) Value
+	// InstanceOf reports whether v is an instance of type t according to
+	// JavaScript's instanceof operator.
+	InstanceOf(t Value) bool
+	// Int returns the value v truncated to an int. It panics if v is not a
+	// JavaScript number.
+	Int() int
+	// Invoke does a JavaScript call of the value v with the given arguments. It
+	// panics if v is not a JavaScript function. The arguments get mapped to
+	// JavaScript values according to the ValueOf function.
+	Invoke(args ...interface{}) Value
+	// IsNaN reports whether v is the JavaScript value "NaN".
+	IsNaN() bool
+	// IsNull reports whether v is the JavaScript value "null".
+	IsNull() bool
+	// IsUndefined reports whether v is the JavaScript value "undefined".
+	IsUndefined() bool
+	// JSValue implements Wrapper interface.
+	JSValue() Value
+	// Length returns the JavaScript property "length" of v. It panics if v is
+	// not a JavaScript object.
+	Length() int
+	// New uses JavaScript's "new" operator with value v as constructor and the
+	// given arguments. It panics if v is not a JavaScript function. The
+	// arguments get mapped to JavaScript values according to the ValueOf
+	// function.
+	New(args ...interface{}) Value
+	// Set sets the JavaScript property p of value v to ValueOf(x). It panics if
+	// v is not a JavaScript object.
+	Set(p string, x interface{})
+	// SetIndex sets the JavaScript index i of value v to ValueOf(x). It panics
+	// if v is not a JavaScript object.
+	SetIndex(i int, x interface{})
+	// String returns the value v as a string. String is a special case because
+	// of Go's String method convention. Unlike the other getters, it does not
+	// panic if v's Type is not TypeString. Instead, it returns a string of the
+	// form "<T>" or "<T: V>" where T is v's type and V is a string
+	// representation of v's value.
+	String() string
+	// Truthy returns the JavaScript "truthiness" of the value v. In JavaScript,
+	// false, 0, "", null, undefined, and NaN are "falsy", and everything else
+	// is "truthy". See
+	// https://developer.mozilla.org/en-US/docs/Glossary/Truthy.
+	Truthy() bool
+	// Type returns the JavaScript type of the value v. It is similar to
+	// JavaScript's typeof operator, except that it returns TypeNull instead of
+	// TypeObject for null.
+	Type() Type
+}
+// Null returns the JavaScript value "null".
+func Null() Value {
+	return null()
+}
+// Undefined returns the JavaScript value "undefined".
+func Undefined() Value {
+	return undefined()
+}
+// ValueOf returns x as a JavaScript value:
+//
+//  | Go                     | JavaScript             |
+//  | ---------------------- | ---------------------- |
+//  | js.Value               | [its value]            |
+//  | js.Func                | function               |
+//  | nil                    | null                   |
+//  | bool                   | boolean                |
+//  | integers and floats    | number                 |
+//  | string                 | string                 |
+//  | []interface{}          | new array              |
+//  | map[string]interface{} | new object             |
+//
+// Panics if x is not one of the expected types.
+func ValueOf(x interface{}) Value {
+	return valueOf(x)
+}
+// Func is the interface that describes a wrapped Go function to be called by
+// JavaScript.
+type Func interface {
+	Value
+	// Release frees up resources allocated for the function. The function must
+	// not be invoked after calling Release.
+	Release()
+}
+// FuncOf returns a wrapped function.
+//
+// Invoking the JavaScript function will synchronously call the Go function fn
+// with the value of JavaScript's "this" keyword and the arguments of the
+// invocation. The return value of the invocation is the result of the Go
+// function mapped back to JavaScript according to ValueOf.
+//
+// A wrapped function triggered during a call from Go to JavaScript gets
+// executed on the same goroutine. A wrapped function triggered by JavaScript's
+// event loop gets executed on an extra goroutine. Blocking operations in the
+// wrapped function will block the event loop. As a consequence, if one wrapped
+// function blocks, other wrapped funcs will not be processed. A blocking
+// function should therefore explicitly start a new goroutine.
+//
+// Func.Release must be called to free up resources when the function will not
+// be used any more.
+func FuncOf(fn func(this Value, args []Value) interface{}) Func {
+	return funcOf(fn)
+}
+// BrowserWindow is the interface that describes the browser window.
+type BrowserWindow interface {
+	Value
+	// The window current url (window.location.href).
+	URL() *url.URL
+	// The window size.
+	Size() (w, h int)
+	// The position of the cursor (mouse or touch).
+	CursorPosition() (x, y int)
+	setCursorPosition(x, y int)
+	// Returns the HTML element with the id property that matches the given id.
+	GetElementByID(id string) Value
+	// Scrolls to the HTML element with the given id.
+	ScrollToID(id string)
+	// AddEventListener subscribes a given handler to the specified event. It
+	// returns a function that must be called to unsubscribe the handler and
+	// release allocated resources.
+	AddEventListener(event string, h EventHandler) func()
+}
+// Event is the interface that describes a javascript event.
+type Event struct {
+	Value
+}
+// PreventDefault cancels the event if it is cancelable. The default action that
+// belongs to the event will not occur.
+func (e Event) PreventDefault() {
+	e.Call("preventDefault")
+}
+// CopyBytesToGo copies bytes from the Uint8Array src to dst. It returns the
+// number of bytes copied, which will be the minimum of the lengths of src and
+// dst.
+//
+// CopyBytesToGo panics if src is not an Uint8Array.
+func CopyBytesToGo(dst []byte, src Value) int {
+	return copyBytesToGo(dst, src)
+}
+// CopyBytesToJS copies bytes from src to the Uint8Array dst. It returns the
+// number of bytes copied, which will be the minimum of the lengths of src and
+// dst.
+//
+// CopyBytesToJS panics if dst is not an Uint8Array.
+func CopyBytesToJS(dst Value, src []byte) int {
+	return copyBytesToJS(dst, src)
+}

js_nowasm.go ADDED Viewed

@@ -0,0 +1,150 @@
+// +build !wasm
+package app
+import (
+	"net/url"
+	"runtime"
+	"github.com/pyros2097/wapp/errors"
+)
+var (
+	errNoWasm = errors.New("unsupported instruction").
+		Tag("required-architecture", "wasm").
+		Tag("current-architecture", runtime.GOARCH)
+)
+type value struct{}
+func (v value) Bool() bool {
+	panic(errNoWasm)
+}
+func (v value) Call(m string, args ...interface{}) Value {
+	panic(errNoWasm)
+}
+func (v value) Float() float64 {
+	panic(errNoWasm)
+}
+func (v value) Get(p string) Value {
+	panic(errNoWasm)
+}
+func (v value) Index(i int) Value {
+	panic(errNoWasm)
+}
+func (v value) InstanceOf(t Value) bool {
+	panic(errNoWasm)
+}
+func (v value) Int() int {
+	panic(errNoWasm)
+}
+func (v value) Invoke(args ...interface{}) Value {
+	panic(errNoWasm)
+}
+func (v value) IsNaN() bool {
+	panic(errNoWasm)
+}
+func (v value) IsNull() bool {
+	panic(errNoWasm)
+}
+func (v value) IsUndefined() bool {
+	panic(errNoWasm)
+}
+func (v value) JSValue() Value {
+	panic(errNoWasm)
+}
+func (v value) Length() int {
+	panic(errNoWasm)
+}
+func (v value) New(args ...interface{}) Value {
+	panic(errNoWasm)
+}
+func (v value) Set(p string, x interface{}) {
+	panic(errNoWasm)
+}
+func (v value) SetIndex(i int, x interface{}) {
+	panic(errNoWasm)
+}
+func (v value) String() string {
+	panic(errNoWasm)
+}
+func (v value) Truthy() bool {
+	panic(errNoWasm)
+}
+func (v value) Type() Type {
+	panic(errNoWasm)
+}
+func null() Value {
+	panic(errNoWasm)
+}
+func undefined() Value {
+	panic(errNoWasm)
+}
+func valueOf(x interface{}) Value {
+	panic(errNoWasm)
+}
+func funcOf(fn func(this Value, args []Value) interface{}) Func {
+	panic(errNoWasm)
+}
+type browserWindow struct {
+	value
+}
+func (w browserWindow) URL() *url.URL {
+	panic(errNoWasm)
+}
+func (w browserWindow) Size() (width, height int) {
+	panic(errNoWasm)
+}
+func (w browserWindow) CursorPosition() (x, y int) {
+	panic(errNoWasm)
+}
+func (w browserWindow) setCursorPosition(x, y int) {
+	panic(errNoWasm)
+}
+func (w *browserWindow) GetElementByID(id string) Value {
+	panic(errNoWasm)
+}
+func (w *browserWindow) ScrollToID(id string) {
+	panic(errNoWasm)
+}
+func (w *browserWindow) AddEventListener(event string, h EventHandler) func() {
+	panic(errNoWasm)
+}
+func copyBytesToGo(dst []byte, src Value) int {
+	panic(errNoWasm)
+}
+func copyBytesToJS(dst Value, src []byte) int {
+	panic(errNoWasm)
+}

js_wasm.go ADDED Viewed

@@ -0,0 +1,247 @@
+package app
+import (
+	"net/url"
+	"reflect"
+	"syscall/js"
+	"github.com/pyros2097/wapp/errors"
+)
+type value struct {
+	js.Value
+}
+func (v value) Call(m string, args ...interface{}) Value {
+	args = cleanArgs(args...)
+	return val(v.Value.Call(m, args...))
+}
+func (v value) Get(p string) Value {
+	return val(v.Value.Get(p))
+}
+func (v value) Set(p string, x interface{}) {
+	if wrapper, ok := x.(Wrapper); ok {
+		x = jsval(wrapper.JSValue())
+	}
+	v.Value.Set(p, x)
+}
+func (v value) Index(i int) Value {
+	return val(v.Value.Index(i))
+}
+func (v value) InstanceOf(t Value) bool {
+	return v.Value.InstanceOf(jsval(t))
+}
+func (v value) Invoke(args ...interface{}) Value {
+	return val(v.Value.Invoke(args...))
+}
+func (v value) JSValue() Value {
+	return v
+}
+func (v value) New(args ...interface{}) Value {
+	args = cleanArgs(args...)
+	return val(v.Value.New(args...))
+}
+func (v value) Type() Type {
+	return Type(v.Value.Type())
+}
+func null() Value {
+	return val(js.Null())
+}
+func undefined() Value {
+	return val(js.Undefined())
+}
+func valueOf(x interface{}) Value {
+	switch t := x.(type) {
+	case value:
+		x = t.Value
+	case function:
+		x = t.fn
+	case *browserWindow:
+		x = t.Value
+	case Event:
+		return valueOf(t.Value)
+	}
+	return val(js.ValueOf(x))
+}
+type function struct {
+	value
+	fn js.Func
+}
+func (f function) Release() {
+	f.fn.Release()
+}
+func funcOf(fn func(this Value, args []Value) interface{}) Func {
+	f := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		wargs := make([]Value, len(args))
+		for i, a := range args {
+			wargs[i] = val(a)
+		}
+		return fn(val(this), wargs)
+	})
+	return function{
+		value: value{Value: f.Value},
+		fn:    f,
+	}
+}
+type browserWindow struct {
+	value
+	cursorX int
+	cursorY int
+}
+func (w *browserWindow) URL() *url.URL {
+	rawurl := w.
+		Get("location").
+		Get("href").
+		String()
+	u, _ := url.Parse(rawurl)
+	return u
+}
+func (w *browserWindow) Size() (width int, height int) {
+	getSize := func(axis string) int {
+		size := w.Get("inner" + axis)
+		if !size.Truthy() {
+			size = w.
+				Get("document").
+				Get("documentElement").
+				Get("client" + axis)
+		}
+		if !size.Truthy() {
+			size = w.
+				Get("document").
+				Get("body").
+				Get("client" + axis)
+		}
+		if size.Type() != TypeNumber {
+			return 0
+		}
+		return size.Int()
+	}
+	return getSize("Width"), getSize("Height")
+}
+func (w *browserWindow) CursorPosition() (x, y int) {
+	return w.cursorX, w.cursorY
+}
+func (w *browserWindow) setCursorPosition(x, y int) {
+	w.cursorX = x
+	w.cursorY = y
+}
+func (w *browserWindow) GetElementByID(id string) Value {
+	return w.Get("document").Call("getElementById", id)
+}
+func (w *browserWindow) ScrollToID(id string) {
+	if elem := w.GetElementByID(id); elem.Truthy() {
+		elem.Call("scrollIntoView")
+	}
+}
+func (w *browserWindow) AddEventListener(event string, h EventHandler) func() {
+	callback := makeJsEventHandler(body, h)
+	w.Call("addEventListener", event, callback)
+	return func() {
+		w.Call("removeEventListener", event, callback)
+		callback.Release()
+	}
+}
+func val(v js.Value) Value {
+	return value{Value: v}
+}
+func jsval(v Value) js.Value {
+	switch v := v.(type) {
+	case value:
+		return v.Value
+	case function:
+		return v.Value
+	case *browserWindow:
+		return v.Value
+	case Event:
+		return jsval(v.Value)
+	default:
+		Log("%s", errors.New("syscall/js value conversion failed").
+			Tag("type", reflect.TypeOf(v)),
+		)
+		return js.Undefined()
+	}
+}
+// JSValue returns the underlying syscall/js value of the given Javascript
+// value.
+func JSValue(v Value) js.Value {
+	return jsval(v)
+}
+func copyBytesToGo(dst []byte, src Value) int {
+	return js.CopyBytesToGo(dst, jsval(src))
+}
+func copyBytesToJS(dst Value, src []byte) int {
+	return js.CopyBytesToJS(jsval(dst), src)
+}
+func cleanArgs(args ...interface{}) []interface{} {
+	for i, a := range args {
+		args[i] = cleanArg(a)
+	}
+	return args
+}
+func cleanArg(v interface{}) interface{} {
+	switch v := v.(type) {
+	case map[string]interface{}:
+		m := make(map[string]interface{}, len(v))
+		for key, val := range v {
+			m[key] = cleanArg(val)
+		}
+		return m
+	case []interface{}:
+		s := make([]interface{}, len(v))
+		for i, val := range v {
+			s[i] = cleanArgs(val)
+		}
+	case Wrapper:
+		return jsval(v.JSValue())
+	}
+	return v
+}

log.go ADDED Viewed

@@ -0,0 +1,48 @@
+package app
+import (
+	"fmt"
+	"runtime"
+)
+var (
+	// DefaultLogger is the logger used to log info and errors.
+	DefaultLogger func(format string, v ...interface{}) = log
+	defaultColor string
+	errorColor   string
+	infoColor    string
+)
+func init() {
+	switch runtime.GOARCH {
+	case "wasm", "window":
+	default:
+		defaultColor = "\033[00m"
+		errorColor = "\033[91m"
+		infoColor = "\033[94m"
+	}
+}
+// Log logs according to a format specifier using the default logger.
+func Log(format string, v ...interface{}) {
+	DefaultLogger(format, v...)
+}
+func log(format string, v ...interface{}) {
+	errorLevel := false
+	for _, a := range v {
+		if _, ok := a.(error); ok {
+			errorLevel = true
+			break
+		}
+	}
+	if errorLevel {
+		fmt.Printf(errorColor+"ERROR ‣ "+defaultColor+format+"\n", v...)
+		return
+	}
+	fmt.Printf(infoColor+"INFO ‣ "+defaultColor+format+"\n", v...)
+}

makefile ADDED Viewed

@@ -0,0 +1,44 @@
+bootstrap:
+	@echo "\033[94m• Setting up go test for wasm to run in the browser\033[00m"
+	go get -u github.com/agnivade/wasmbrowsertest
+	mv ${GOPATH}/bin/wasmbrowsertest ${GOPATH}/bin/go_js_wasm_exec
+.PHONY: test
+test:
+	@echo "\033[94m• Running Go vet\033[00m"
+	go vet ./...
+	@echo "\033[94m\n• Running Go tests\033[00m"
+	go test -race ./...
+	@echo "\033[94m\n• Running go wasm tests\033[00m"
+	GOARCH=wasm GOOS=js go test ./pkg/app
+release: test
+ifdef VERSION
+	@echo "\033[94m\n• Releasing ${VERSION}\033[00m"
+	@git tag ${VERSION}
+	@git push origin ${VERSION}
+else
+	@echo "\033[94m\n• Releasing version\033[00m"
+	@echo "\033[91mVERSION is not defided\033[00m"
+	@echo "~> make VERSION=\033[90mv6.0.0\033[00m release"
+endif
+build:
+	@echo "\033[94m• Building go-app documentation PWA\033[00m"
+	@GOARCH=wasm GOOS=js go build -o docs/web/app.wasm ./docs/src
+	@echo "\033[94m• Building go-app documentation\033[00m"
+	@go build -o docs/documentation ./docs/src
+run: build
+	@echo "\033[94m• Running go-app documentation server\033[00m"
+	@cd docs && ./documentation local
+github: build
+	@echo "\033[94m• Generating GitHub Pages\033[00m"
+	@cd docs && ./documentation github
+clean:
+	@go clean -v ./...
+	-@rm docs/documentation

node.go ADDED Viewed

@@ -0,0 +1,203 @@
+package app
+import (
+	"context"
+	"fmt"
+	"io"
+	"reflect"
+	"github.com/pyros2097/wapp/errors"
+)
+// UI is the interface that describes a user interface element such as
+// components and HTML elements.
+type UI interface {
+	// Kind represents the specific kind of a UI element.
+	Kind() Kind
+	// JSValue returns the javascript value linked to the element.
+	JSValue() Value
+	// Reports whether the element is mounted.
+	Mounted() bool
+	name() string
+	self() UI
+	setSelf(UI)
+	context() context.Context
+	attributes() map[string]string
+	eventHandlers() map[string]eventHandler
+	parent() UI
+	setParent(UI)
+	children() []UI
+	mount() error
+	dismount()
+	update(UI) error
+}
+// Kind represents the specific kind of a user interface element.
+type Kind uint
+func (k Kind) String() string {
+	switch k {
+	case SimpleText:
+		return "text"
+	case HTML:
+		return "html"
+	case Selector:
+		return "selector"
+	case RawHTML:
+		return "raw"
+	case FunctionalComponent:
+		return "function"
+	default:
+		return "undefined"
+	}
+}
+const (
+	// UndefinedElem represents an undefined UI element.
+	UndefinedElem Kind = iota
+	// SimpleText represents a simple text element.
+	SimpleText
+	// HTML represents an HTML element.
+	HTML
+	// Component represents a customized, independent and reusable UI element.
+	Component
+	// Selector represents an element that is used to select a subset of
+	// elements within a given list.
+	Selector
+	// RawHTML represents an HTML element obtained from a raw HTML code snippet.
+	RawHTML
+	FunctionalComponent
+)
+// FilterUIElems returns a filtered version of the given UI elements where
+// selector elements such as If and Range are interpreted and removed. It also
+// remove nil elements.
+//
+// It should be used only when implementing components that can accept content
+// with variadic arguments like HTML elements Body method.
+func FilterUIElems(uis ...UI) []UI {
+	if len(uis) == 0 {
+		return nil
+	}
+	elems := make([]UI, 0, len(uis))
+	for _, n := range uis {
+		// Ignore nil elements:
+		if v := reflect.ValueOf(n); n == nil ||
+			v.Kind() == reflect.Ptr && v.IsNil() {
+			continue
+		}
+		switch n.Kind() {
+		case SimpleText, HTML, Component, RawHTML:
+			elems = append(elems, n)
+		case Selector:
+			elems = append(elems, n.children()...)
+		default:
+			panic(errors.New("filtering ui elements failed").
+				Tag("reason", "unexpected element type found").
+				Tag("kind", n.Kind()).
+				Tag("name", n.name()),
+			)
+		}
+	}
+	return elems
+}
+// EventHandler represents a function that can handle HTML events. They are
+// always called on the UI goroutine.
+type EventHandler func(ctx Context, e Event)
+type eventHandler struct {
+	event   string
+	jsvalue Func
+	value   EventHandler
+}
+func (h eventHandler) equal(o eventHandler) bool {
+	return h.event == o.event &&
+		fmt.Sprintf("%p", h.value) == fmt.Sprintf("%p", o.value)
+}
+func makeJsEventHandler(src UI, h EventHandler) Func {
+	return FuncOf(func(this Value, args []Value) interface{} {
+		dispatch(func() {
+			if !src.Mounted() {
+				return
+			}
+			ctx := Context{
+				Context: src.context(),
+				Src:     src,
+				JSSrc:   src.JSValue(),
+			}
+			event := Event{
+				Value: args[0],
+			}
+			trackMousePosition(event)
+			h(ctx, event)
+		})
+		return nil
+	})
+}
+func trackMousePosition(e Event) {
+	x := e.Get("clientX")
+	if !x.Truthy() {
+		return
+	}
+	y := e.Get("clientY")
+	if !y.Truthy() {
+		return
+	}
+	Window().setCursorPosition(x.Int(), y.Int())
+}
+func isErrReplace(err error) bool {
+	_, replace := errors.Tag(err, "replace")
+	return replace
+}
+func mount(n UI) error {
+	n.setSelf(n)
+	return n.mount()
+}
+func dismount(n UI) {
+	n.dismount()
+	n.setSelf(nil)
+}
+func update(a, b UI) error {
+	a.setSelf(a)
+	b.setSelf(b)
+	return a.update(b)
+}
+type WritableNode interface {
+	Html(w io.Writer)
+	HtmlWithIndent(w io.Writer, indent int)
+}

node_test.go ADDED Viewed

@@ -0,0 +1,177 @@
+package app
+import (
+	"fmt"
+	"testing"
+	"github.com/pyros2097/wapp/errors"
+	"github.com/stretchr/testify/require"
+)
+func TestKindString(t *testing.T) {
+	utests := []struct {
+		kind           Kind
+		expectedString string
+	}{
+		{
+			kind:           UndefinedElem,
+			expectedString: "undefined",
+		},
+		{
+			kind:           SimpleText,
+			expectedString: "text",
+		},
+		{
+			kind:           HTML,
+			expectedString: "html",
+		},
+		// {
+		// 	kind:           Component,
+		// 	expectedString: "component",
+		// },
+		{
+			kind:           Selector,
+			expectedString: "selector",
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.expectedString, func(t *testing.T) {
+			require.Equal(t, u.expectedString, u.kind.String())
+		})
+	}
+}
+func TestFilterUIElems(t *testing.T) {
+	var nilText *text
+	simpleText := Text("hello")
+	expectedResult := []UI{
+		simpleText,
+	}
+	res := FilterUIElems(nil, nilText, simpleText)
+	require.Equal(t, expectedResult, res)
+}
+func TestIsErrReplace(t *testing.T) {
+	utests := []struct {
+		scenario     string
+		err          error
+		isErrReplace bool
+	}{
+		{
+			scenario:     "error is a replace error",
+			err:          errors.New("test").Tag("replace", true),
+			isErrReplace: true,
+		},
+		{
+			scenario:     "error is not a replace error",
+			err:          errors.New("test").Tag("test", true),
+			isErrReplace: false,
+		},
+		{
+			scenario:     "standard error is not a replace error",
+			err:          fmt.Errorf("test"),
+			isErrReplace: false,
+		},
+		{
+			scenario:     "nil error is not a replace error",
+			err:          nil,
+			isErrReplace: false,
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			res := isErrReplace(u.err)
+			require.Equal(t, u.isErrReplace, res)
+		})
+	}
+}
+type mountTest struct {
+	scenario string
+	node     UI
+}
+func testMountDismount(t *testing.T, utests []mountTest) {
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			testSkipNonWasm(t)
+			n := u.node
+			err := mount(n)
+			require.NoError(t, err)
+			testMounted(t, n)
+			dismount(u.node)
+			testDismounted(t, n)
+		})
+	}
+}
+func testMounted(t *testing.T, n UI) {
+	require.NotNil(t, n.JSValue())
+	require.True(t, n.Mounted())
+	switch n.Kind() {
+	case HTML, Component:
+		require.NoError(t, n.context().Err())
+		require.NotNil(t, n.self())
+	}
+	for _, c := range n.children() {
+		require.Equal(t, n, c.parent())
+		testMounted(t, c)
+	}
+}
+func testDismounted(t *testing.T, n UI) {
+	require.Nil(t, n.JSValue())
+	require.False(t, n.Mounted())
+	switch n.Kind() {
+	case HTML, Component:
+		require.Error(t, n.context().Err())
+		require.Nil(t, n.self())
+	}
+	for _, c := range n.children() {
+		testDismounted(t, c)
+	}
+}
+type updateTest struct {
+	scenario   string
+	a          UI
+	b          UI
+	matches    []TestUIDescriptor
+	replaceErr bool
+}
+func testUpdate(t *testing.T, utests []updateTest) {
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			testSkipNonWasm(t)
+			err := mount(u.a)
+			require.NoError(t, err)
+			defer dismount(u.a)
+			err = update(u.a, u.b)
+			if u.replaceErr {
+				require.Error(t, err)
+				require.True(t, isErrReplace(err))
+				return
+			}
+			require.NoError(t, err)
+			for _, d := range u.matches {
+				require.NoError(t, TestMatch(u.a, d))
+			}
+		})
+	}
+}

range.go ADDED Viewed

@@ -0,0 +1,151 @@
+package app
+import (
+	"context"
+	"net/url"
+	"reflect"
+	"sort"
+	"github.com/pyros2097/wapp/errors"
+)
+// RangeLoop represents a control structure that iterates within a slice, an
+// array or a map.
+type RangeLoop interface {
+	UI
+	// Slice sets the loop content by repeating the given function for the
+	// number of elements in the source.
+	//
+	// It panics if the range source is not a slice or an array.
+	Slice(f func(int) UI) RangeLoop
+	// Map sets the loop content by repeating the given function for the number
+	// of elements in the source. Elements are ordered by keys.
+	//
+	// It panics if the range source is not a map or if map keys are not strings.
+	Map(f func(string) UI) RangeLoop
+}
+// Range returns a range loop that iterates within the given source. Source must
+// be a slice, an array or a map with strings as keys.
+func Range(src interface{}) RangeLoop {
+	return rangeLoop{source: src}
+}
+type rangeLoop struct {
+	body   []UI
+	source interface{}
+}
+func (r rangeLoop) Slice(f func(int) UI) RangeLoop {
+	src := reflect.ValueOf(r.source)
+	if src.Kind() != reflect.Slice && src.Kind() != reflect.Array {
+		panic(errors.New("range loop source is not a slice or array").
+			Tag("src-type", src.Type),
+		)
+	}
+	body := make([]UI, 0, src.Len())
+	for i := 0; i < src.Len(); i++ {
+		body = append(body, FilterUIElems(f(i))...)
+	}
+	r.body = body
+	return r
+}
+func (r rangeLoop) Map(f func(string) UI) RangeLoop {
+	src := reflect.ValueOf(r.source)
+	if src.Kind() != reflect.Map {
+		panic(errors.New("range loop source is not a map").
+			Tag("src-type", src.Type),
+		)
+	}
+	if keyType := src.Type().Key(); keyType.Kind() != reflect.String {
+		panic(errors.New("range loop source keys are not strings").
+			Tag("src-type", src.Type).
+			Tag("key-type", keyType),
+		)
+	}
+	body := make([]UI, 0, src.Len())
+	keys := make([]string, 0, src.Len())
+	for _, k := range src.MapKeys() {
+		keys = append(keys, k.String())
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		body = append(body, FilterUIElems(f(k))...)
+	}
+	r.body = body
+	return r
+}
+func (r rangeLoop) Kind() Kind {
+	return Selector
+}
+func (r rangeLoop) JSValue() Value {
+	return nil
+}
+func (r rangeLoop) Mounted() bool {
+	return false
+}
+func (r rangeLoop) name() string {
+	return "range"
+}
+func (r rangeLoop) self() UI {
+	return r
+}
+func (r rangeLoop) setSelf(UI) {
+}
+func (r rangeLoop) context() context.Context {
+	return nil
+}
+func (r rangeLoop) attributes() map[string]string {
+	return nil
+}
+func (r rangeLoop) eventHandlers() map[string]eventHandler {
+	return nil
+}
+func (r rangeLoop) parent() UI {
+	return nil
+}
+func (r rangeLoop) setParent(UI) {
+}
+func (r rangeLoop) children() []UI {
+	return r.body
+}
+func (r rangeLoop) mount() error {
+	return errors.New("range loop is not mountable").
+		Tag("name", r.name()).
+		Tag("kind", r.Kind())
+}
+func (r rangeLoop) dismount() {
+}
+func (r rangeLoop) update(UI) error {
+	return errors.New("range loop cannot be updated").
+		Tag("name", r.name()).
+		Tag("kind", r.Kind())
+}
+func (r rangeLoop) onNav(*url.URL) {
+}

range_test.go ADDED Viewed

@@ -0,0 +1,91 @@
+package app
+import "testing"
+func TestRange(t *testing.T) {
+	testUpdate(t, []updateTest{
+		{
+			scenario: "range slice is updated",
+			a: Div().Body(
+				Range([]string{"hello", "world"}).Slice(func(i int) UI {
+					src := []string{"hello", "world"}
+					return Text(src[i])
+				}),
+			),
+			b: Div().Body(
+				Range([]string{"hello", "maxoo"}).Slice(func(i int) UI {
+					src := []string{"hello", "maxoo"}
+					return Text(src[i])
+				}),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: Text("hello"),
+				},
+				{
+					Path:     TestPath(1),
+					Expected: Text("maxoo"),
+				},
+			},
+		},
+		{
+			scenario: "range slice is updated to be empty",
+			a: Div().Body(
+				Range([]string{"hello", "world"}).Slice(func(i int) UI {
+					src := []string{"hello", "world"}
+					return Text(src[i])
+				}),
+			),
+			b: Div().Body(
+				Range([]string{}).Slice(func(i int) UI {
+					src := []string{"hello", "maxoo"}
+					return Text(src[i])
+				}),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: nil,
+				},
+				{
+					Path:     TestPath(1),
+					Expected: nil,
+				},
+			},
+		},
+		{
+			scenario: "range map is updated",
+			a: Div().Body(
+				Range(map[string]string{"key": "value"}).Map(func(k string) UI {
+					src := map[string]string{"key": "value"}
+					return Text(src[k])
+				}),
+			),
+			b: Div().Body(
+				Range(map[string]string{"key": "value"}).Map(func(k string) UI {
+					src := map[string]string{"key": "maxoo"}
+					return Text(src[k])
+				}),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: Text("maxoo"),
+				},
+			},
+		},
+	})
+}

raw.go ADDED Viewed

@@ -0,0 +1,173 @@
+package app
+import (
+	"context"
+	"io"
+	"strings"
+	"github.com/pyros2097/wapp/errors"
+)
+// Raw returns a ui element from the given raw value. HTML raw value must have a
+// single root.
+//
+// It is not recommended to use this kind of node since there is no check on the
+// raw string content.
+func Raw(v string) UI {
+	v = strings.TrimSpace(v)
+	tag := rawRootTagName(v)
+	if tag == "" {
+		panic(errors.New("creating raw element failed").
+			Tag("reason", "opening tag not found"))
+	}
+	return &raw{
+		value: v,
+		tag:   tag,
+	}
+}
+type raw struct {
+	jsvalue    Value
+	parentElem UI
+	tag        string
+	value      string
+}
+func (r *raw) Kind() Kind {
+	return RawHTML
+}
+func (r *raw) JSValue() Value {
+	return r.jsvalue
+}
+func (r *raw) Mounted() bool {
+	return r.jsvalue != nil
+}
+func (r *raw) name() string {
+	return "raw." + r.tag
+}
+func (r *raw) self() UI {
+	return r
+}
+func (r *raw) setSelf(UI) {
+}
+func (r *raw) context() context.Context {
+	return nil
+}
+func (r *raw) attributes() map[string]string {
+	return nil
+}
+func (r *raw) eventHandlers() map[string]eventHandler {
+	return nil
+}
+func (r *raw) parent() UI {
+	return r.parentElem
+}
+func (r *raw) setParent(p UI) {
+	r.parentElem = p
+}
+func (r *raw) children() []UI {
+	return nil
+}
+func (r *raw) mount() error {
+	if r.Mounted() {
+		return errors.New("mounting raw html element failed").
+			Tag("reason", "already mounted").
+			Tag("name", r.name()).
+			Tag("kind", r.Kind())
+	}
+	wrapper := Window().Get("document").Call("createElement", "div")
+	wrapper.Set("innerHTML", r.value)
+	value := wrapper.Get("firstChild")
+	if !value.Truthy() {
+		return errors.New("mounting raw html element failed").
+			Tag("reason", "converting raw html to html elements returned nil").
+			Tag("name", r.name()).
+			Tag("kind", r.Kind()).
+			Tag("raw-html", r.value)
+	}
+	wrapper.Call("removeChild", value)
+	r.jsvalue = value
+	return nil
+}
+func (r *raw) dismount() {
+	r.jsvalue = nil
+}
+func (r *raw) update(n UI) error {
+	if !r.Mounted() {
+		return nil
+	}
+	if n.Kind() != r.Kind() || r.name() != r.name() {
+		return errors.New("updating raw html element failed").
+			Tag("replace", true).
+			Tag("reason", "different element types").
+			Tag("current-kind", r.Kind()).
+			Tag("current-name", r.name()).
+			Tag("updated-kind", n.Kind()).
+			Tag("updated-name", n.name())
+	}
+	if v := n.(*raw).value; r.value != v {
+		return errors.New("updating raw html element failed").
+			Tag("replace", true).
+			Tag("reason", "different raw values").
+			Tag("current-value", r.value).
+			Tag("new-value", v)
+	}
+	return nil
+}
+func (r *raw) Html(w io.Writer) {
+	r.HtmlWithIndent(w, 0)
+}
+func (r *raw) HtmlWithIndent(w io.Writer, indent int) {
+	writeIndent(w, indent)
+	w.Write(stob(r.value))
+	w.Write(ln())
+}
+func rawRootTagName(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if strings.HasPrefix(raw, "</") || !strings.HasPrefix(raw, "<") {
+		return ""
+	}
+	end := -1
+	for i := 1; i < len(raw); i++ {
+		if raw[i] == ' ' ||
+			raw[i] == '\t' ||
+			raw[i] == '\n' ||
+			raw[i] == '>' {
+			end = i
+			break
+		}
+	}
+	if end <= 0 {
+		return ""
+	}
+	return raw[1:end]
+}

raw_test.go ADDED Viewed

@@ -0,0 +1,116 @@
+package app
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+func TestRawRootTagName(t *testing.T) {
+	tests := []struct {
+		scenario string
+		raw      string
+		expected string
+	}{
+		{
+			scenario: "tag set",
+			raw: `
+			<div>
+				<span></span>
+			</div>`,
+			expected: "div",
+		},
+		{
+			scenario: "tag is empty",
+		},
+		{
+			scenario: "opening tag missing",
+			raw:      "</div>",
+		},
+		{
+			scenario: "tag is not set",
+			raw:      "div",
+		},
+		{
+			scenario: "tag is not closing",
+			raw:      "<div",
+		},
+		{
+			scenario: "tag is not closing",
+			raw:      "<div",
+		},
+		{
+			scenario: "tag without value",
+			raw:      "<>",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.scenario, func(t *testing.T) {
+			tag := rawRootTagName(test.raw)
+			require.Equal(t, test.expected, tag)
+		})
+	}
+}
+func TestRawMountDismount(t *testing.T) {
+	testMountDismount(t, []mountTest{
+		{
+			scenario: "raw html element",
+			node:     Raw(`<h1>Hello</h1>`),
+		},
+		{
+			scenario: "raw svg element",
+			node:     Raw(`<svg></svg>`),
+		},
+	})
+}
+func TestRawUpdate(t *testing.T) {
+	testUpdate(t, []updateTest{
+		{
+			scenario:   "raw html element returns replace error when updated with a non text-element",
+			a:          Raw("<svg></svg>"),
+			b:          Div(),
+			replaceErr: true,
+		},
+		{
+			scenario: "raw html element is replace by another raw html element",
+			a: Div().Body(
+				Raw("<div></div>"),
+			),
+			b: Div().Body(
+				Raw("<svg></svg>"),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: Raw("<svg></svg>"),
+				},
+			},
+		},
+		{
+			scenario: "raw html element is replace by non-raw html element",
+			a: Div().Body(
+				Raw("<div></div>"),
+			),
+			b: Div().Body(
+				Text("hello"),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: Text("hello"),
+				},
+			},
+		},
+	})
+}

readme.md ADDED Viewed

@@ -0,0 +1,64 @@
+<p align="center">
+    <a href="https://goreportcard.com/report/github.com/pyros2097/wapp"><img src="https://goreportcard.com/badge/github.com/pyros2097/wapp" alt="Go Report Card"></a>
+	<a href="https://GitHub.com/pyros2097/wapp/releases/"><img src="https://img.shields.io/github/release/pyros2097/wapp.svg" alt="GitHub release"></a>
+	<a href="https://pkg.go.dev/github.com/pyros2097/wapp/v7/pkg/app"><img src="https://img.shields.io/badge/dev-reference-007d9c?logo=go&logoColor=white&style=flat" alt="pkg.go.dev docs"></a>
+</p>
+**wapp** is a package to build [isomorphic web apps](https://developers.google.com/web/progressive-web-apps/) with [Go](https://golang.org) and [WebAssembly](https://webassembly.org).
+It uses a [declarative syntax](#declarative-syntax) that allows creating and dealing with HTML elements only by using Go, and without writing any HTML markup. The syntax is inspired by react and its awesome hooks and functional component features.
+This originally started out as of fork of this awesome golang PWA framework [go-app](https://github.com/pyros2097/wapp). All credits goes to Maxence Charriere for majority of the work.
+## Install
+**wapp** requirements:
+- [Go 1.15](https://golang.org/doc/go1.15)
+```sh
+go mod init
+go get -u -v github.com/pyros2097/wapp
+```
+## Declarative syntax
+**go-app** uses a declarative syntax so you can write component-based UI elements just by using the Go programming language.
+```go
+package pages
+import (
+	"github.com/pyros2097/wapp"
+)
+func Index(c *app.RenderContext) app.UI {
+	count, setCount := c.UseInt(0)
+	onclick := func(ctx app.Context, e app.Event) {
+		setCount(count() + 1)
+	}
+	return app.Div().
+		Body(
+			app.Div().
+				Style("cursor", "pointer").
+				OnClick(onclick).
+				Body(
+					app.Text(count()),
+				),
+			app.Text("id: "+id.(string)),
+		)
+}
+```
+The directory should look like as the following:
+```sh
+.
+├── pages
+    └── index.go
+    └── about.go
+└── static
+    └── favicon.png
+    └── logo.png
+```

resource.go ADDED Viewed

@@ -0,0 +1,151 @@
+// +build !wasm
+package app
+import (
+	"net/http"
+	"strings"
+)
+// ResourceProvider is the interface that describes a provider for resources.
+//
+// App resources are the mandatory resources required to run a PWA. They are
+// generated by the Handler and are accessible from the root path. Eg:
+//  "/app-worker.js"
+//  "/manifest.json"
+//  "/wasm_exec.js"
+//
+// Static resources are the resources used by the PWA such as the web assembly
+// binary, styles, scripts, or images. They can be located on a localhost or a
+// remote bucket. In order to avoid confusion with PWA required resources,
+// static resources URL paths are always prefixed by "/web". Eg:
+//  "/web/app.wasm"
+//  "/web/main.css"
+//  "/web/background.jpg"
+//
+// If the resource provider is an http.Handler, the handler is used to serve
+// static resources requests.
+type ResourceProvider interface {
+	// The path to the root directory where app resources are accessible.
+	AppResources() string
+	// The path or URL where the web directory that contains static resources is
+	// located.
+	StaticResources() string
+	// The URL of the app.wasm file. This must match the pattern:
+	//  StaticResources/web/WASM_FILE.
+	AppWASM() string
+	// The URL of the robots.txt file. This must match the pattern:
+	//  StaticResources/web/robots.txt.
+	RobotsTxt() string
+	// The URL of the ads.txt file. This must match the pattern:
+	//  StaticResources/web/ads.txt.
+	AdsTxt() string
+}
+// LocalDir returns a resource provider that serves static resources from a
+// local directory located at the given path.
+func LocalDir(path string) ResourceProvider {
+	return localDir{
+		Handler: http.StripPrefix("/web/", http.FileServer(http.Dir(path))),
+		path:    path,
+	}
+}
+type localDir struct {
+	http.Handler
+	path string
+}
+func (d localDir) AppResources() string {
+	return ""
+}
+func (d localDir) StaticResources() string {
+	return ""
+}
+func (d localDir) AppWASM() string {
+	return "/web/app.wasm"
+}
+func (d localDir) RobotsTxt() string {
+	return "/web/robots.txt"
+}
+func (d localDir) AdsTxt() string {
+	return "/web/ads.txt"
+}
+// RemoteBucket returns a resource provider that provides resources from a
+// remote bucket such as Amazon S3 or Google Cloud Storage.
+func RemoteBucket(url string) ResourceProvider {
+	url = strings.TrimSuffix(url, "/")
+	url = strings.TrimSuffix(url, "/web")
+	return remoteBucket{
+		url: url,
+	}
+}
+type remoteBucket struct {
+	url string
+}
+func (b remoteBucket) AppResources() string {
+	return ""
+}
+func (b remoteBucket) StaticResources() string {
+	return b.url
+}
+func (b remoteBucket) AppWASM() string {
+	return b.StaticResources() + "/web/app.wasm"
+}
+func (b remoteBucket) RobotsTxt() string {
+	return b.StaticResources() + "/web/robots.txt"
+}
+func (b remoteBucket) AdsTxt() string {
+	return b.StaticResources() + "/web/ads.txt"
+}
+// GitHubPages returns a resource provider that provides resources from GitHub
+// pages. This provider must only be used to generate static websites with the
+// GenerateStaticWebsite function.
+func GitHubPages(repoName string) ResourceProvider {
+	if !strings.HasPrefix(repoName, "/") {
+		repoName = "/" + repoName
+	}
+	return gitHubPages{repo: repoName}
+}
+type gitHubPages struct {
+	repo string
+}
+func (g gitHubPages) AppResources() string {
+	return g.repo
+}
+func (g gitHubPages) StaticResources() string {
+	return g.repo
+}
+func (g gitHubPages) AppWASM() string {
+	return g.StaticResources() + "/web/app.wasm"
+}
+func (g gitHubPages) RobotsTxt() string {
+	return g.StaticResources() + "/web/robots.txt"
+}
+func (g gitHubPages) AdsTxt() string {
+	return g.StaticResources() + "/web/ads.txt"
+}

resource_test.go ADDED Viewed

@@ -0,0 +1,85 @@
+// +build !wasm
+package app
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+func TestLocalDir(t *testing.T) {
+	testSkipWasm(t)
+	utests := []struct {
+		scenario string
+		provider ResourceProvider
+	}{
+		{
+			scenario: "from web directory",
+			provider: LocalDir("web"),
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			h := u.provider.(localDir)
+			require.Empty(t, h.StaticResources())
+			require.Equal(t, "/web/app.wasm", h.AppWASM())
+			require.Equal(t, "/web/robots.txt", h.RobotsTxt())
+			require.Equal(t, "/web/ads.txt", h.AdsTxt())
+			close := testCreateDir(t, "web")
+			defer close()
+			resources := []string{
+				"/web/test",
+				h.AppWASM(),
+				h.RobotsTxt(),
+			}
+			for _, r := range resources {
+				t.Run(r, func(t *testing.T) {
+					path := strings.Replace(r, "/web", h.path, 1)
+					err := ioutil.WriteFile(path, stob("hello"), 0666)
+					require.NoError(t, err)
+					req := httptest.NewRequest(http.MethodGet, r, nil)
+					res := httptest.NewRecorder()
+					h.ServeHTTP(res, req)
+					require.Equal(t, "hello", res.Body.String())
+				})
+			}
+		})
+	}
+}
+func TestRemoteBucket(t *testing.T) {
+	utests := []struct {
+		scenario string
+		provider ResourceProvider
+	}{
+		{
+			scenario: "remote bucket",
+			provider: RemoteBucket("https://storage.googleapis.com/test"),
+		},
+		{
+			scenario: "remote bucket with web suffix",
+			provider: RemoteBucket("https://storage.googleapis.com/test/web/"),
+		},
+	}
+	for _, u := range utests {
+		t.Run(u.scenario, func(t *testing.T) {
+			require.Equal(t, "https://storage.googleapis.com/test", u.provider.StaticResources())
+			require.Equal(t, "https://storage.googleapis.com/test/web/app.wasm", u.provider.AppWASM())
+			require.Equal(t, "https://storage.googleapis.com/test/web/robots.txt", u.provider.RobotsTxt())
+			require.Equal(t, "https://storage.googleapis.com/test/web/ads.txt", u.provider.AdsTxt())
+		})
+	}
+}

storage.go ADDED Viewed

@@ -0,0 +1,29 @@
+package app
+var (
+	// LocalStorage is a storage that uses the browser local storage associated
+	// to the document origin. Data stored has no expiration time.
+	LocalStorage BrowserStorage
+	// SessionStorage is a storage that uses the browser session storage
+	// associated to the document origin. Data stored expire when the page
+	// session ends.
+	SessionStorage BrowserStorage
+)
+// BrowserStorage is the interface that describes a web browser storage.
+type BrowserStorage interface {
+	// Set sets the value to the given key. The value must be json convertible.
+	Set(k string, v interface{}) error
+	// Get gets the item associated to the given key and store it in the given
+	// value.
+	// It returns an error if v is not a pointer.
+	Get(k string, v interface{}) error
+	// Del deletes the item associated with the given key.
+	Del(k string)
+	// Clear deletes all items.
+	Clear()
+}

storage_nowasm.go ADDED Viewed

@@ -0,0 +1,39 @@
+// +build !wasm
+package app
+import "encoding/json"
+func init() {
+	LocalStorage = make(memoryStorage)
+	SessionStorage = make(memoryStorage)
+}
+type memoryStorage map[string][]byte
+func (s memoryStorage) Set(k string, v interface{}) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	s[k] = b
+	return nil
+}
+func (s memoryStorage) Get(k string, v interface{}) error {
+	if _, ok := s[k]; !ok {
+		return nil
+	}
+	return json.Unmarshal(s[k], v)
+}
+func (s memoryStorage) Del(k string) {
+	delete(s, k)
+}
+func (s memoryStorage) Clear() {
+	for k := range s {
+		delete(s, k)
+	}
+}

storage_test.go ADDED Viewed

@@ -0,0 +1,154 @@
+package app
+import (
+	"fmt"
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+func TestLocalStorage(t *testing.T) {
+	testBrowserStorage(t, LocalStorage)
+}
+func TestLocalStorageFull(t *testing.T) {
+	testBrowserStorageFull(t, LocalStorage)
+}
+func TestSessionStorage(t *testing.T) {
+	testBrowserStorage(t, SessionStorage)
+}
+func TestSessionStorageFull(t *testing.T) {
+	testBrowserStorageFull(t, SessionStorage)
+}
+type obj struct {
+	Foo int
+	Bar string
+}
+func testBrowserStorage(t *testing.T, s BrowserStorage) {
+	tests := []struct {
+		scenario string
+		function func(*testing.T, BrowserStorage)
+	}{
+		{
+			scenario: "key does not exists",
+			function: testBrowserStorageGetNotExists,
+		},
+		{
+			scenario: "key is set and get",
+			function: testBrowserStorageSetGet,
+		},
+		{
+			scenario: "key is deleted",
+			function: testBrowserStorageDel,
+		},
+		{
+			scenario: "storage is cleared",
+			function: testBrowserStorageClear,
+		},
+		{
+			scenario: "set a non json value returns an error",
+			function: testBrowserStorageSetError,
+		},
+		{
+			scenario: "get with non json value receiver returns an error",
+			function: testBrowserStorageGetError,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.scenario, func(t *testing.T) {
+			test.function(t, s)
+		})
+	}
+}
+func testBrowserStorageGetNotExists(t *testing.T, s BrowserStorage) {
+	var o obj
+	err := s.Get("/notexists", &o)
+	require.NoError(t, err)
+	require.Zero(t, o)
+}
+func testBrowserStorageSetGet(t *testing.T, s BrowserStorage) {
+	var o obj
+	err := s.Set("/exists", obj{
+		Foo: 42,
+		Bar: "hello",
+	})
+	require.NoError(t, err)
+	err = s.Get("/exists", &o)
+	require.NoError(t, err)
+	require.Equal(t, 42, o.Foo)
+	require.Equal(t, "hello", o.Bar)
+}
+func testBrowserStorageDel(t *testing.T, s BrowserStorage) {
+	var o obj
+	err := s.Set("/deleted", obj{
+		Foo: 42,
+		Bar: "bye",
+	})
+	require.NoError(t, err)
+	s.Del("/deleted")
+	err = s.Get("/deleted", &o)
+	require.NoError(t, err)
+	require.Zero(t, o)
+}
+func testBrowserStorageClear(t *testing.T, s BrowserStorage) {
+	var o obj
+	err := s.Set("/cleared", obj{
+		Foo: 42,
+		Bar: "sayonara",
+	})
+	require.NoError(t, err)
+	s.Clear()
+	err = s.Get("/cleared", &o)
+	require.NoError(t, err)
+	require.Zero(t, o)
+}
+func testBrowserStorageSetError(t *testing.T, s BrowserStorage) {
+	err := s.Set("/func", func() {})
+	require.Error(t, err)
+}
+func testBrowserStorageGetError(t *testing.T, s BrowserStorage) {
+	err := s.Set("/value", obj{
+		Foo: 42,
+		Bar: "omae",
+	})
+	require.NoError(t, err)
+	var f func()
+	err = s.Get("/value", &f)
+	require.Error(t, err)
+}
+func testBrowserStorageFull(t *testing.T, s BrowserStorage) {
+	testSkipNonWasm(t)
+	var err error
+	data := make([]byte, 4096)
+	i := 0
+	for {
+		key := fmt.Sprintf("/key_%d", i)
+		if err = s.Set(key, data); err != nil {
+			break
+		}
+		i++
+	}
+	require.Error(t, err)
+	t.Log(err)
+}

storage_wasm.go ADDED Viewed

@@ -0,0 +1,72 @@
+package app
+import (
+	"encoding/json"
+	"sync"
+	"syscall/js"
+	"github.com/pyros2097/wapp/errors"
+)
+func init() {
+	LocalStorage = newJSStorage("localStorage")
+	SessionStorage = newJSStorage("sessionStorage")
+}
+type jsStorage struct {
+	name  string
+	mutex sync.RWMutex
+}
+func newJSStorage(name string) *jsStorage {
+	return &jsStorage{name: name}
+}
+func (s *jsStorage) Set(k string, v interface{}) (err error) {
+	defer func() {
+		r := recover()
+		if r != nil {
+			err = errors.New("setting storage value failed").
+				Tag("storage-type", s.name).
+				Tag("key", k).
+				Wrap(r.(js.Error))
+		}
+	}()
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	Window().Get(s.name).Call("setItem", k, btos(b))
+	return nil
+}
+func (s *jsStorage) Get(k string, v interface{}) error {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	item := Window().Get(s.name).Call("getItem", k)
+	if !item.Truthy() {
+		return nil
+	}
+	return json.Unmarshal(stob(item.String()), v)
+}
+func (s *jsStorage) Del(k string) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	Window().Get(s.name).Call("removeItem", k)
+}
+func (s *jsStorage) Clear() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	Window().Get(s.name).Call("clear")
+}

strings.go ADDED Viewed

@@ -0,0 +1,45 @@
+package app
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"unsafe"
+)
+func toString(v interface{}) string {
+	switch v := v.(type) {
+	case string:
+		return v
+	case []byte:
+		return btos(v)
+	case int:
+		return strconv.Itoa(v)
+	case float64:
+		return strconv.FormatFloat(v, 'f', 4, 64)
+	default:
+		return fmt.Sprint(v)
+	}
+}
+func writeIndent(w io.Writer, indent int) {
+	for i := 0; i < indent*4; i++ {
+		w.Write(stob(" "))
+	}
+}
+func ln() []byte {
+	return stob("\n")
+}
+func btos(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
+func stob(s string) []byte {
+	return *(*[]byte)(unsafe.Pointer(&s))
+}

testing.go ADDED Viewed

@@ -0,0 +1,289 @@
+package app
+import (
+	"fmt"
+	"github.com/pyros2097/wapp/errors"
+)
+// TestUIDescriptor represents a descriptor that describes a UI element and its
+// location from its parents.
+type TestUIDescriptor struct {
+	// The location of the node. It is used by the TestMatch to find the
+	// element to test.
+	//
+	// If empty, the expected UI element is compared with the root of the tree.
+	//
+	// Otherwise, each integer represents the index of the element to traverse,
+	// from the root's children to the element to compare
+	Path []int
+	// The element to compare with the element targeted by Path. Compare
+	// behavior varies depending on the element kind.
+	//
+	// Simple text elements only have their text value compared.
+	//
+	// HTML elements have their attribute compared and check if their event
+	// handlers are set.
+	//
+	// Components have their exported field values compared.
+	Expected UI
+}
+// TestPath is a helper function that returns a path to use in a
+// TestUIDescriptor.
+func TestPath(p ...int) []int {
+	return p
+}
+// TestMatch looks for the element targeted by the descriptor in the given tree
+// and reports whether it matches with the expected element.
+//
+// Eg:
+//  tree := app.Div().Body(
+//      app.H2().Body(
+//          app.Text("foo"),
+//      ),
+//      app.P().Body(
+//          app.Text("bar"),
+//      ),
+//  )
+//
+//  // Testing root:
+//  err := app.TestMatch(tree, app.TestUIDescriptor{
+//      Path:     TestPath(),
+//      Expected: app.Div(),
+//  })
+//  // OK => err == nil
+//
+//  // Testing h2:
+//  err := app.TestMatch(tree, app.TestUIDescriptor{
+//      Path:     TestPath(0),
+//      Expected: app.H3(),
+//  })
+//  // KO => err != nil because we ask h2 to match with h3
+//
+//  // Testing text from p:
+//  err = app.TestMatch(tree, app.TestUIDescriptor{
+//      Path:     TestPath(1, 0),
+//      Expected: app.Text("bar"),
+//  })
+//  // OK => err == nil
+func TestMatch(tree UI, d TestUIDescriptor) error {
+	if !tree.Mounted() {
+		if err := mount(tree); err != nil {
+			return err
+		}
+	}
+	if d.Expected != nil {
+		d.Expected.setSelf(d.Expected)
+	}
+	if len(d.Path) != 0 {
+		idx := d.Path[0]
+		if idx < 0 || idx >= len(tree.children()) {
+			// Check that the element does not exists.
+			if d.Expected == nil {
+				return nil
+			}
+			return errors.New("ui element to match is out of range").
+				Tag("name", d.Expected.name()).
+				Tag("kind", d.Expected.Kind()).
+				Tag("parent-name", tree.name()).
+				Tag("parent-kind", tree.Kind()).
+				Tag("parent-children-count", len(tree.children())).
+				Tag("index", idx)
+		}
+		c := tree.children()[idx]
+		p := c.parent()
+		if p != tree {
+			return errors.New("unexpected ui element parent").
+				Tag("name", d.Expected.name()).
+				Tag("kind", d.Expected.Kind()).
+				Tag("parent-name", p.name()).
+				Tag("parent-kind", p.Kind()).
+				Tag("parent-addr", fmt.Sprintf("%p", p)).
+				Tag("expected-parent-name", tree.name()).
+				Tag("expected-parent-kind", tree.Kind()).
+				Tag("expected-parent-addr", fmt.Sprintf("%p", tree))
+		}
+		d.Path = d.Path[1:]
+		return TestMatch(c, d)
+	}
+	if d.Expected.name() != tree.name() || d.Expected.Kind() != tree.Kind() {
+		return errors.New("the UI element is not matching the descriptor").
+			Tag("expected-name", d.Expected.name()).
+			Tag("expected-kind", d.Expected.Kind()).
+			Tag("current-name", tree.name()).
+			Tag("current-kind", tree.Kind())
+	}
+	switch d.Expected.Kind() {
+	case SimpleText:
+		return matchText(tree, d)
+	case HTML:
+		if err := matchHTMLElemAttrs(tree, d); err != nil {
+			return err
+		}
+		return matchHTMLElemEventHandlers(tree, d)
+	// case Component:
+	// 	return matchComponent(tree, d)
+	case RawHTML:
+		return matchRaw(tree, d)
+	default:
+		return errors.New("the UI element is not matching the descriptor").
+			Tag("reason", "unavailable matching for the kind").
+			Tag("kind", d.Expected.Kind())
+	}
+}
+func matchText(n UI, d TestUIDescriptor) error {
+	a := n.(*text)
+	b := d.Expected.(*text)
+	if a.value != b.value {
+		return errors.New("the text element is not matching the descriptor").
+			Tag("name", a.name()).
+			Tag("reason", "unexpected text value").
+			Tag("expected-value", b.value).
+			Tag("current-value", a.value)
+	}
+	return nil
+}
+func matchHTMLElemAttrs(n UI, d TestUIDescriptor) error {
+	aAttrs := n.attributes()
+	bAttrs := d.Expected.attributes()
+	if len(aAttrs) != len(bAttrs) {
+		return errors.New("the html element is not matching the descriptor").
+			Tag("name", n.name()).
+			Tag("reason", "unexpected attributes length").
+			Tag("expected-attributes-length", len(bAttrs)).
+			Tag("current-attributes-length", len(aAttrs))
+	}
+	for k, b := range bAttrs {
+		a, exists := aAttrs[k]
+		if !exists {
+			return errors.New("the html element is not matching the descriptor").
+				Tag("name", n.name()).
+				Tag("reason", "an attribute is missing").
+				Tag("attribute", k)
+		}
+		if a != b {
+			return errors.New("the html element is not matching the descriptor").
+				Tag("name", n.name()).
+				Tag("reason", "unexpected attribute value").
+				Tag("attribute", k).
+				Tag("expected-value", b).
+				Tag("current-value", a)
+		}
+	}
+	for k := range bAttrs {
+		_, exists := bAttrs[k]
+		if !exists {
+			return errors.New("the html element is not matching the descriptor").
+				Tag("name", n.name()).
+				Tag("reason", "an unexpected attribute is present").
+				Tag("attribute", k)
+		}
+	}
+	return nil
+}
+func matchHTMLElemEventHandlers(n UI, d TestUIDescriptor) error {
+	aevents := n.eventHandlers()
+	bevents := d.Expected.eventHandlers()
+	if len(aevents) != len(bevents) {
+		return errors.New("the html element is not matching the descriptor").
+			Tag("name", n.name()).
+			Tag("reason", "unexpected event handlers length").
+			Tag("expected-event-handlers-length", len(bevents)).
+			Tag("current-event-handlers-length", len(aevents))
+	}
+	for k := range bevents {
+		_, exists := aevents[k]
+		if !exists {
+			return errors.New("the html element is not matching the descriptor").
+				Tag("name", n.name()).
+				Tag("reason", "an event handler is missing").
+				Tag("event-handler", k)
+		}
+	}
+	for k := range bevents {
+		_, exists := aevents[k]
+		if !exists {
+			return errors.New("the html element is not matching the descriptor").
+				Tag("name", n.name()).
+				Tag("reason", "an unexpected event handler is present").
+				Tag("event-handler", k)
+		}
+	}
+	return nil
+}
+// func matchComponent(n UI, d TestUIDescriptor) error {
+// 	aval := reflect.ValueOf(n).Elem()
+// 	bval := reflect.ValueOf(d.Expected).Elem()
+// 	compotype := reflect.TypeOf(Compo{})
+// 	for i := 0; i < bval.NumField(); i++ {
+// 		a := aval.Field(i)
+// 		b := bval.Field(i)
+// 		if a.Type() == compotype {
+// 			continue
+// 		}
+// 		if !a.CanSet() {
+// 			continue
+// 		}
+// 		if !reflect.DeepEqual(a.Interface(), b.Interface()) {
+// 			return errors.New("the component is not matching with the descriptor").
+// 				Tag("name", n.name()).
+// 				Tag("reason", "unexpected field value").
+// 				Tag("field", bval.Type().Field(i).Name).
+// 				Tag("expected-value", b.Interface()).
+// 				Tag("current-value", a.Interface())
+// 		}
+// 	}
+// 	return nil
+// }
+func matchRaw(n UI, d TestUIDescriptor) error {
+	a := n.(*raw)
+	b := d.Expected.(*raw)
+	if a.value != b.value {
+		return errors.New("the raw html element is not matching with the descriptor").
+			Tag("name", n.name()).
+			Tag("reason", "unexpected value").
+			Tag("expected-value", b.value).
+			Tag("current-value", a.value)
+	}
+	return nil
+}

testing_test.go ADDED Viewed

@@ -0,0 +1,46 @@
+package app
+import (
+	"io/ioutil"
+	"os"
+	"runtime"
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+func testSkipNonWasm(t *testing.T) {
+	if goarch := runtime.GOARCH; goarch != "wasm" {
+		t.Skip("skipping test")
+		// t.Skip(logs.New("skipping test").
+		// 	Tag("reason", "unsupported architecture").
+		// 	Tag("required-architecture", "wasm").
+		// 	Tag("current-architecture", goarch),
+		// )
+	}
+}
+func testSkipWasm(t *testing.T) {
+	if goarch := runtime.GOARCH; goarch == "wasm" {
+		t.Skip("skipping test")
+		// t.Skip(logs.New("skipping test").
+		// 	Tag("reason", "unsupported architecture").
+		// 	Tag("required-architecture", "!= than wasm").
+		// 	Tag("current-architecture", goarch),
+		// )
+	}
+}
+func testCreateDir(t *testing.T, path string) func() {
+	err := os.MkdirAll(path, 0755)
+	require.NoError(t, err)
+	return func() {
+		os.RemoveAll(path)
+	}
+}
+func testCreateFile(t *testing.T, path, content string) {
+	err := ioutil.WriteFile(path, stob(content), 0666)
+	require.NoError(t, err)
+}

text.go ADDED Viewed

@@ -0,0 +1,120 @@
+package app
+import (
+	"context"
+	"io"
+	"github.com/pyros2097/wapp/errors"
+)
+// Text creates a simple text element.
+func Text(v interface{}) UI {
+	return &text{value: toString(v)}
+}
+type text struct {
+	jsvalue    Value
+	parentElem UI
+	value      string
+}
+func (t *text) Kind() Kind {
+	return SimpleText
+}
+func (t *text) JSValue() Value {
+	return t.jsvalue
+}
+func (t *text) Mounted() bool {
+	return t.jsvalue != nil
+}
+func (t *text) name() string {
+	return "text"
+}
+func (t *text) self() UI {
+	return t
+}
+func (t *text) setSelf(n UI) {
+}
+func (t *text) context() context.Context {
+	return context.TODO()
+}
+func (t *text) attributes() map[string]string {
+	return nil
+}
+func (t *text) eventHandlers() map[string]eventHandler {
+	return nil
+}
+func (t *text) parent() UI {
+	return t.parentElem
+}
+func (t *text) setParent(p UI) {
+	t.parentElem = p
+}
+func (t *text) children() []UI {
+	return nil
+}
+func (t *text) mount() error {
+	if t.Mounted() {
+		return errors.New("mounting ui element failed").
+			Tag("reason", "already mounted").
+			Tag("kind", t.Kind()).
+			Tag("name", t.name()).
+			Tag("value", t.value)
+	}
+	t.jsvalue = Window().
+		Get("document").
+		Call("createTextNode", t.value)
+	return nil
+}
+func (t *text) dismount() {
+	t.jsvalue = nil
+}
+func (t *text) update(n UI) error {
+	if !t.Mounted() {
+		return nil
+	}
+	o, isText := n.(*text)
+	if !isText {
+		return errors.New("updating ui element failed").
+			Tag("replace", true).
+			Tag("reason", "different element types").
+			Tag("current-kind", t.Kind()).
+			Tag("current-name", t.name()).
+			Tag("updated-kind", n.Kind()).
+			Tag("updated-name", n.name())
+	}
+	if t.value != o.value {
+		t.value = o.value
+		t.jsvalue.Set("nodeValue", o.value)
+	}
+	return nil
+}
+func (t *text) Html(w io.Writer) {
+	t.HtmlWithIndent(w, 0)
+}
+func (t *text) HtmlWithIndent(w io.Writer, indent int) {
+	writeIndent(w, indent)
+	// html.EscapeString(
+	w.Write(stob(t.value))
+}

text_test.go ADDED Viewed

@@ -0,0 +1,103 @@
+package app
+import "testing"
+func TestTextMountDismout(t *testing.T) {
+	testMountDismount(t, []mountTest{
+		{
+			scenario: "text",
+			node:     Text("hello"),
+		},
+	})
+}
+func TestTextUpdate(t *testing.T) {
+	testUpdate(t, []updateTest{
+		{
+			scenario:   "text element returns replace error when updated with a non text-element",
+			a:          Text("hello"),
+			b:          Div(),
+			replaceErr: true,
+		},
+		{
+			scenario: "text element is updated",
+			a:        Text("hello"),
+			b:        Text("world"),
+			matches: []TestUIDescriptor{
+				{
+					Expected: Text("world"),
+				},
+			},
+		},
+		{
+			scenario: "text is replaced by a html elem",
+			a: Div().Body(
+				Text("hello"),
+			),
+			b: Div().Body(
+				H2().Text("hello"),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: H2(),
+				},
+				{
+					Path:     TestPath(0, 0),
+					Expected: Text("hello"),
+				},
+			},
+		},
+		{
+			scenario: "text is replaced by a component",
+			a: Div().Body(
+				Text("hello"),
+			),
+			// b: Div().Body(
+			// 	&hello{},
+			// ),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				// {
+				// 	Path:     TestPath(0),
+				// 	Expected: &hello{},
+				// },
+				{
+					Path:     TestPath(0, 0, 0),
+					Expected: H1(),
+				},
+				{
+					Path:     TestPath(0, 0, 0, 0),
+					Expected: Text("hello, "),
+				},
+			},
+		},
+		{
+			scenario: "text is replaced by a raw html element",
+			a: Div().Body(
+				Text("hello"),
+			),
+			b: Div().Body(
+				Raw("<svg></svg>"),
+			),
+			matches: []TestUIDescriptor{
+				{
+					Path:     TestPath(),
+					Expected: Div(),
+				},
+				{
+					Path:     TestPath(0),
+					Expected: Raw("<svg></svg>"),
+				},
+			},
+		},
+	})
+}