add more interfaces

cmd/dom/main.go

@@ -2,24 +2,12 @@ package main
 
 import (
 	dom "github.com/brettlangdon/go-dom/v1"
-	console "github.com/brettlangdon/go-dom/v1/console"
-	document "github.com/brettlangdon/go-dom/v1/document"
+	"github.com/brettlangdon/go-dom/v1/console"
+	"github.com/brettlangdon/go-dom/v1/document"
 )
 
-func onClick(evt *dom.Event) {
-	elm := evt.GetTarget().ToElement()
-	console.Log(evt, elm)
-}
-
 func main() {
-	id := "app"
-	app := document.GetElementById(id)
-	if app == nil {
-		console.Error("Could not find element with id %s\r\n", id)
-		return
-	}
-
-	document.AddEventListener("click", dom.NewEventCallback(onClick))
-	stop := make(chan int)
-	<-stop
+	app := document.GetElementById("app")
+	shadow := app.AttachShadow(dom.ShadowRootInit{Mode: "open"})
+	console.Dir(shadow)
 }

customelementregistry.go

@@ -0,0 +1,31 @@
+// DO NOT EDIT - generated file
+package dom
+
+import "syscall/js"
+
+type CustomElementRegistry struct {
+	Value
+}
+
+func NewCustomElementRegistry(v js.Value) *CustomElementRegistry {
+	val := Value{Value: v}
+	if val.IsNull() || val.IsUndefined() {
+		return nil
+	}
+	return val.ToCustomElementRegistry()
+}
+func (v Value) ToCustomElementRegistry() *CustomElementRegistry {
+	return &CustomElementRegistry{Value: v}
+}
+func (c *CustomElementRegistry) Define(name string, constructor interface{}) Value {
+	val := Value{Value: c.Call("define", ToJSValue(name), ToJSValue(constructor))}
+	return val
+}
+func (c *CustomElementRegistry) Get(name string) Value {
+	val := Value{Value: c.Call("get", ToJSValue(name))}
+	return val
+}
+func (c *CustomElementRegistry) WhenDefined(name string) *Promise {
+	val := Value{Value: c.Call("whenDefined", ToJSValue(name))}
+	return NewPromise(val.JSValue())
+}

customelements/customelementregistry.go

@@ -0,0 +1,20 @@
+// DO NOT EDIT - generated file
+package customelements
+
+import "syscall/js"
+import dom "github.com/brettlangdon/go-dom/v1"
+
+var c *dom.CustomElementRegistry
+
+func init() {
+	c = dom.NewCustomElementRegistry(js.Global().Get("customElements"))
+}
+func Define(name string, constructor interface{}) dom.Value {
+	return c.Define(name, constructor)
+}
+func Get(name string) dom.Value {
+	return c.Get(name)
+}
+func WhenDefined(name string) *dom.Promise {
+	return c.WhenDefined(name)
+}

document.go

@@ -102,6 +102,10 @@ func (d *Document) QuerySelectorAll(selector string) []*Element {
 	}
 	return elms
 }
+func (d *Document) AttachShadow(shadowRootInit ShadowRootInit) *ShadowRoot {
+	val := Value{Value: d.Call("attachShadow", ToJSValue(shadowRootInit))}
+	return NewShadowRoot(val.JSValue())
+}
 func (d *Document) GetClassName() string {
 	val := Value{Value: d.Get("className")}
 	return val.String()

document/document.go

@@ -69,6 +69,9 @@ func QuerySelector(selector string) *dom.Element {
 func QuerySelectorAll(selector string) []*dom.Element {
 	return d.QuerySelectorAll(selector)
 }
+func AttachShadow(shadowRootInit dom.ShadowRootInit) *dom.ShadowRoot {
+	return d.AttachShadow(shadowRootInit)
+}
 func GetClassName() string {
 	return d.GetClassName()
 }

element.go

@@ -78,6 +78,10 @@ func (e *Element) QuerySelectorAll(selector string) []*Element {
 	}
 	return elms
 }
+func (e *Element) AttachShadow(shadowRootInit ShadowRootInit) *ShadowRoot {
+	val := Value{Value: e.Call("attachShadow", ToJSValue(shadowRootInit))}
+	return NewShadowRoot(val.JSValue())
+}
 func (e *Element) GetClassName() string {
 	val := Value{Value: e.Get("className")}
 	return val.String()

elementiface.go

@@ -4,4 +4,5 @@ package dom
 type ElementIFace interface {
 	QuerySelector(selector string) *Element
 	QuerySelectorAll(selector string) []*Element
+	AttachShadow(shadowRootInit ShadowRootInit) *ShadowRoot
 }

generate/customelementregistry.json

@@ -0,0 +1,39 @@
+{
+  "Type": "CustomElementRegistry",
+  "ImportJS": true,
+  "GlobalAPI": "customElements",
+  "Functions": [
+    {
+      "Name": "define",
+      "Arguments": [
+        {
+          "Name": "name",
+          "Type": "string"
+        },
+        {
+          "Name": "constructor",
+          "Type": "interface{}"
+        }
+      ]
+    },
+    {
+      "Name": "get",
+      "Arguments": [
+        {
+          "Name": "name",
+          "Type": "string"
+        }
+      ]
+    },
+    {
+      "Name": "whenDefined",
+      "Arguments": [
+        {
+          "Name": "name",
+          "Type": "string"
+        }
+      ],
+      "ReturnType": "*Promise"
+    }
+  ]
+}

generate/elementiface.json

@@ -35,6 +35,16 @@
         }
       ],
       "ReturnType": "[]*Element"
+    },
+    {
+      "Name": "attachShadow",
+      "Arguments": [
+        {
+          "Name": "shadowRootInit",
+          "Type": "ShadowRootInit"
+        }
+      ],
+      "ReturnType": "*ShadowRoot"
     }
   ]
 }

generate/main.go

@@ -87,6 +87,10 @@ func (t TypeStructure) writeReturnValue(out *bytes.Buffer, rt string) error {
 		out.WriteString("return val")
 	case "NodeIFace":
 		out.WriteString("return NewNode(val.JSValue())\r\n")
+	case "*ShadowRoot":
+		out.WriteString("return NewShadowRoot(val.JSValue())\r\n")
+	case "*Promise":
+		out.WriteString("return NewPromise(val.JSValue())\r\n")
 	case "*Element":
 		out.WriteString("return NewElement(val.JSValue())\r\n")
 	case "[]*Element":
@@ -167,6 +171,10 @@ func (t TypeStructure) writeAPIFunctions(out *bytes.Buffer, funcs []TypeFunction
 				rt = "dom.JSValue"
 			} else if rt == "*Callback" {
 				rt = "*dom.Callback"
+			} else if rt == "*Promise" {
+				rt = "*dom.Promise"
+			} else if rt == "ShadowRootInit" {
+				rt = "dom.ShadowRootInit"
 			}
 
 			if arg.Varidic {

generate/promise.json

@@ -0,0 +1,4 @@
+{
+  "Type": "Promise",
+  "ImportJS": true
+}

generate/shadowroot.json

@@ -0,0 +1,24 @@
+{
+  "Type": "ShadowRoot",
+  "ImportJS": true,
+  "Implements": [
+    "EventTargetIFace",
+    "NodeIFace"
+  ],
+  "Properties": [
+    {
+      "Name": "mode",
+      "Type": "string",
+      "ReadOnly": true
+    },
+    {
+      "Name": "host",
+      "Type": "*Element",
+      "ReadOnly": true
+    },
+    {
+      "Name": "innerHTML",
+      "Type": "string"
+    }
+  ]
+}

promise.go

@@ -0,0 +1,17 @@
+// DO NOT EDIT - generated file
+package dom
+
+import "syscall/js"
+
+type Promise struct {
+	Value
+}
+
+func NewPromise(v js.Value) *Promise {
+	val := Value{Value: v}
+	if val.IsNull() || val.IsUndefined() {
+		return nil
+	}
+	return val.ToPromise()
+}
+func (v Value) ToPromise() *Promise { return &Promise{Value: v} }

shadowroot.go

@@ -0,0 +1,83 @@
+// DO NOT EDIT - generated file
+package dom
+
+import "syscall/js"
+
+type ShadowRoot struct {
+	Value
+}
+
+func NewShadowRoot(v js.Value) *ShadowRoot {
+	val := Value{Value: v}
+	if val.IsNull() || val.IsUndefined() {
+		return nil
+	}
+	return val.ToShadowRoot()
+}
+func (v Value) ToShadowRoot() *ShadowRoot { return &ShadowRoot{Value: v} }
+func (s *ShadowRoot) GetMode() string {
+	val := Value{Value: s.Get("mode")}
+	return val.String()
+}
+func (s *ShadowRoot) GetHost() *Element {
+	val := Value{Value: s.Get("host")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetInnerHTML() string {
+	val := Value{Value: s.Get("innerHTML")}
+	return val.String()
+}
+func (s *ShadowRoot) SetInnerHTML(v string) {
+	s.Set("innerHTML", v)
+}
+func (s *ShadowRoot) AddEventListener(t string, listener *Callback) Value {
+	val := Value{Value: s.Call("addEventListener", ToJSValue(t), ToJSValue(listener))}
+	return val
+}
+func (s *ShadowRoot) AppendChild(aChild *Element) *Element {
+	val := Value{Value: s.Call("appendChild", ToJSValue(aChild))}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetBaseURI() string {
+	val := Value{Value: s.Get("baseURI")}
+	return val.String()
+}
+func (s *ShadowRoot) GetFirstChild() *Element {
+	val := Value{Value: s.Get("firstChild")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetLastChild() *Element {
+	val := Value{Value: s.Get("lastChild")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetNextSibling() *Element {
+	val := Value{Value: s.Get("nextSibling")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetPreviousSibling() *Element {
+	val := Value{Value: s.Get("previousSibling")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetParentElement() *Element {
+	val := Value{Value: s.Get("parentElement")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetRootElement() *Element {
+	val := Value{Value: s.Get("rootElement")}
+	return NewElement(val.JSValue())
+}
+func (s *ShadowRoot) GetPrefix() string {
+	val := Value{Value: s.Get("prefix")}
+	return val.String()
+}
+func (s *ShadowRoot) GetNodeName() string {
+	val := Value{Value: s.Get("nodeName")}
+	return val.String()
+}
+func (s *ShadowRoot) GetTextContent() string {
+	val := Value{Value: s.Get("textContent")}
+	return val.String()
+}
+func (s *ShadowRoot) SetTextContent(v string) {
+	s.Set("textContent", v)
+}

shadowrootinit.go

@@ -0,0 +1,14 @@
+package dom
+
+import "syscall/js"
+
+type ShadowRootInit struct {
+	Value
+	Mode string
+}
+
+func (s ShadowRootInit) JSValue() js.Value {
+	v := js.Global().Get("Object").New()
+	v.Set("mode", s.Mode)
+	return v
+}