v/vlib/jsdom/dom.js.v

// DOM API for JS backend
module jsdom

[heap]
pub struct JS.Node {
	baseURI         JS.String   [noinit]
	childNodes      JS.NodeList [noinit]
	firstChild      voidptr     [noinit]
	isConnected     JS.bool     [noinit]
	lastChild       voidptr     [noinit]
	nextSibling     voidptr     [noinit]
	nodeName        JS.String   [noinit]
	nodeType        NodeType    [noinit]
	nodeValue       voidptr     [noinit]
	ownerDocument   JS.Document [noinit]
	parentNode      voidptr     [noinit]
	parentElement   JS.Element  [noinit]
	previousSibling voidptr     [noinit]
	textContext     voidptr
}

pub struct JS.NodeList {
pub mut:
	length JS.Number
}

pub enum NodeType {
	element = 1
	attribute = 2
	text = 3
	cdata_section = 4
	entity_reference = 5
	entity = 6
	processing_instruction = 7
	comment = 8
	document = 9
	document_type = 10
	document_fragment = 11
	notation = 12
}

pub struct Node {
	node JS.Node [noinit]
}

pub fn (n Node) typ() NodeType {
	return n.node.nodeType
}

/// IEventTarget interface is implemented by objects that can receive events and may have listeners for them.
// In other words, any target of events implements the three methods associated with this interface.
// TODO: remove_event_listener and dispatch_event
pub interface IEventTarget {
	add_event_listener(event string, cb EventCallback)
}

/// The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus
// letting those object types to be used similarly and often interchangeably. As an abstract class,
// there is no such thing as a plain Node object. All objects that implement Node functionality are based on one of its subclasses.
// Most notable are Document, Element, and DocumentFragment.
pub interface INode {
	IEventTarget
	typ() NodeType
}

pub fn (elem Node) add_event_listener(event string, cb EventCallback) {
	#elem.node.addEventListener(event.str, function (event) { let e = jsdom__dispatch_event_target(this);
	#let ev = jsdom__dispatch_event(event); ev.event = event;
	#return cb(e,ev)
	#});
}

pub fn (n INode) is_(ty NodeType) bool {
	res := false
	#res.val = n.node.nodeType == ty

	return res
}

pub fn (n INode) document() ?Document {
	res := Document{}
	if n.is_(.document) {
		#res.node = n.node

		return res
	} else {
		return none
	}
}

pub fn (n INode) element() ?Element {
	res := Element{}
	if n.is_(.element) {
		#res.node = n.node

		return res
	} else {
		return none
	}
}

pub fn (n INode) append_child(child INode) {
	#n.node.appendChild(child.node)
}

pub fn (n INode) clone_node(deep ...int) INode {
	cloned := Node{}
	if deep.len == 0 {
		#cloned.node = n.node.cloneNode()
	} else {
		#cloned.node = n.node.cloneNode(deep.arr.get(new int(0)).val)
	}
	return cloned
}

pub fn (n INode) contains(other INode) bool {
	res := false
	#res.val = n.node.contains(other.node)

	return res
}

pub fn (n INode) get_root_node() INode {
	root := Node{}
	#root.node = n.node.getRootNode()

	return root
}

pub fn (n INode) has_child_nodes() bool {
	res := false
	#res.val = n.node.hasChildNodes()

	return res
}

pub fn (n INode) insert_before(new_node INode, reference_node INode) Node {
	inserted := Node{}
	#inserted.node = n.node.insertBefore(new_node.node,reference_node.node)

	return inserted
}

/*
pub fn (x Node) == (y Node) bool {
	res := false
	#res.val = x.node.isEqualNode(y.node)

	return res
}*/

pub fn (n INode) remove_child(child INode) {
	#n.node.removeChild(child.node)
}

pub fn (n INode) replace_child(new_child INode, old_child INode) INode {
	#old_child.node = n.node.replace_child(new_child.node,old_child.node)

	return old_child
}

pub struct JS.EventTarget {}

fn dispatch_event_target(target JS.EventTarget) IEventTarget {
	mut ret := IEventTarget(Element{})
	#if (target instanceof HTMLCanvasElement) { ret = new jsdom__HTMLCanvasElement({}); ret.node = target; }
	#else if (target instanceof HTMLElement) { ret = new jsdom__HTMLElement({}); ret.node = target; }
	#else if (target instanceof Window) { ret = new jsdom__Window({}); ret.node = target;}
	#else if (target instanceof SVGElement) { ret = new jsdom__SVGElement({}); ret.node = target; }
	#else if (target instanceof Element) { ret = new jsdom__Element({}); ret.node = target; }
	#else if (target instanceof Document) { ret = new jsdom__Document({}); ret.node = target; }

	return ret
}

pub type EventCallback = fn (_ IEventTarget, _ IEvent)

pub const (
	document = Document{}
	window   = Window{}
)

fn init() {
	#jsdom__document.node = document;
	#jsdom__window.node = window;
}

pub struct JS.DOMMatrix {
pub:
	is_2d       JS.Boolean [noinit]
	is_identity JS.Boolean [noinit]
pub mut:
	m11 JS.Number [noinit]
	m12 JS.Number [noinit]
	m13 JS.Number [noinit]
	m14 JS.Number [noinit]
	m21 JS.Number [noinit]
	m22 JS.Number [noinit]
	m23 JS.Number [noinit]
	m24 JS.Number [noinit]
	m31 JS.Number [noinit]
	m32 JS.Number [noinit]
	m33 JS.Number [noinit]
	m34 JS.Number [noinit]
	m41 JS.Number [noinit]
	m42 JS.Number [noinit]
	m43 JS.Number [noinit]
	m44 JS.Number [noinit]
	a   JS.Number [noinit]
	b   JS.Number [noinit]
	c   JS.Number [noinit]
	d   JS.Number [noinit]
	e   JS.Number [noinit]
	f   JS.Number [noinit]
}

pub struct DOMMatrix {
	matrix JS.DOMMatrix [noinit]
}

pub fn (matrix DOMMatrix) str() string {
	fmt := ''
	#fmt.str = matrix.matrix + ''

	return fmt
}

pub fn new_matrix(init []f64) DOMMatrix {
	#let tmp = new Array();

	for val in init {
		_ := val
		#tmp.push(val);
	}
	mut m := JS.DOMMatrix{}
	#m = new DOMMatrix(tmp);

	return DOMMatrix{m}
}

pub fn (m DOMMatrix) invert_self() {
	#m.matrix.invertSelf();
}

pub fn (m DOMMatrix) is_2d() bool {
	res := false
	#res.val = m.matrix.is2D.val;

	return res
}