dom

package
v0.3.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 5, 2025 License: MIT Imports: 15 Imported by: 0

Documentation

Overview

Package dom provides the fundamental DOM implementation for Gost-DOM.

The DOM includes a Node implementation, and it's fundamental special types, such as Element, Document, Text, etc; as well as events througn the EventTarget type.

Specific implementation of HTML element types, including the HTMLDocument, is in the html package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsDOMError 

func IsDOMError(err error) bool

func IsInvalidCharacterError 

func IsInvalidCharacterError(err error) bool

func IsNotImplementedError 

func IsNotImplementedError(err error) bool

func IsSyntaxError 

func IsSyntaxError(err error) bool

func NoError 

func NoError[T func(U), U any](f T) func(U) error

NoError takes a function accepting a single argument and has no return value, and transforms it into a function that can be used where an error return value is expected.

func SetEventTargetSelf 

func SetEventTargetSelf(t EventTarget)

Types

type Attr 

type Attr interface {
	Node
	LocalName() string
	Name() string
	NamespaceURI() string
	OwnerElement() Element
	Prefix() string
	Value() string
	SetValue(val string)
	// contains filtered or unexported methods
}

Attr is the interface corresponding to the Attr DOM node

type Attributes 

type Attributes []Attr

TODO: In the DOM, this is a `NamedNodeMap`. Is that useful in Go?

func (Attributes) Length 

func (attrs Attributes) Length() int

type CharacterData 

type CharacterData interface {
	Node
	Data() string
	Length() int
}

type Comment 

type Comment interface {
	CharacterData
}

func NewComment 

func NewComment(text string, ownerDocument Document) Comment

type CustomEvent 

type CustomEvent interface {
	Event
}

func NewCustomEvent 

func NewCustomEvent(eventType string, options ...EventOption) CustomEvent

type DOMError 

type DOMError struct {
	// contains filtered or unexported fields
}

type DOMTokenList 

type DOMTokenList struct {
	// contains filtered or unexported fields
}

func NewClassList 

func NewClassList(element Element) DOMTokenList

func NewDOMTokenList added in v0.2.0 

func NewDOMTokenList(attribute string, element Element) DOMTokenList

func (DOMTokenList) Add 

func (l DOMTokenList) Add(tokens ...string) error

func (DOMTokenList) All 

func (l DOMTokenList) All() iter.Seq[string]

func (DOMTokenList) Contains 

func (l DOMTokenList) Contains(token string) bool

func (DOMTokenList) Item 

func (l DOMTokenList) Item(index int) *string

func (DOMTokenList) Length 

func (l DOMTokenList) Length() int

func (DOMTokenList) Remove 

func (l DOMTokenList) Remove(token string)

func (DOMTokenList) Replace 

func (l DOMTokenList) Replace(oldToken string, newToken string) bool

func (DOMTokenList) SetValue 

func (l DOMTokenList) SetValue(val string)

func (DOMTokenList) Toggle 

func (l DOMTokenList) Toggle(token string) bool

func (DOMTokenList) Value 

func (l DOMTokenList) Value() string

type Document 

type Document interface {
	RootNode
	Body() Element
	Head() Element
	CreateDocumentFragment() DocumentFragment
	CreateAttribute(string) Attr
	CreateText(data string) Text
	CreateComment(data string) Comment
	CreateDocumentType(name string) DocumentType
	CreateElementNS(string, string) Element
	CreateElement(string) Element
	DocumentElement() Element
	// contains filtered or unexported methods
}

func NewDocument 

func NewDocument(window DocumentParentWindow) Document

type DocumentEvent 

type DocumentEvent = string
const (
	DocumentEventDOMContentLoaded DocumentEvent = "DOMContentLoaded"
	DocumentEventLoad             DocumentEvent = "load"
)

type DocumentFragment 

type DocumentFragment interface {
	RootNode
}

func NewDocumentFragment 

func NewDocumentFragment(ownerDocument Document) DocumentFragment

type DocumentParentWindow deprecated 

type DocumentParentWindow interface {
	EventTarget
	ParseFragment(ownerDocument Document, reader io.Reader) (DocumentFragment, error)
}

Deprecated: This interface is part of an implementation details, and it was an oversight that it wasn't placed in an internal package. This will be removed from the public API in a future version

type DocumentType 

type DocumentType interface {
	Node
	Name() string
}

func NewDocumentType 

func NewDocumentType(name string, ownerDocument Document) DocumentType

type Element 

type Element interface {
	ElementContainer
	MouseEvents
	ClassList() DOMTokenList
	HasAttribute(name string) bool
	GetAttribute(name string) (string, bool)
	SetAttribute(name string, value string)
	GetAttributeNode(string) Attr
	SetAttributeNode(Attr) (Attr, error)
	RemoveAttributeNode(Attr) (Attr, error)
	Attributes() NamedNodeMap
	InsertAdjacentHTML(position string, text string) error
	OuterHTML() string
	InnerHTML() string
	TagName() string
	Matches(string) (bool, error)
	// contains filtered or unexported methods
}

An Element in the document. Can be either an [HTMLElement] or an [XMLElement]

func NewElement 

func NewElement(tagName string, ownerDocument Document) Element

type ElementContainer 

type ElementContainer interface {
	Node
	ParentNode
}

ElementContainer defines common functionality in Document, DocumentFragment, and Element. While they all have Node as the direct base class in the DOM spec; they share a common set of functions operating on elements

type ErrorEvent 

type ErrorEvent interface {
	Event
	Err() error
	Error() string
}

func NewErrorEvent 

func NewErrorEvent(err error) ErrorEvent

type Event 

type Event interface {
	entity.Entity
	Cancelable() bool
	Bubbles() bool
	PreventDefault()
	Type() string
	StopPropagation()
	Target() EventTarget
	CurrentTarget() EventTarget
	// contains filtered or unexported methods
}

func NewEvent 

func NewEvent(eventType string, options ...EventOption) Event

type EventHandler 

type EventHandler interface {
	// HandleEvent is called when the the event occurrs.
	//
	// An non-nil error return value will dispatch an error event on the global
	// object in a normally configured environment.
	HandleEvent(event Event) error
	// Equals must return true, if they underlying event handler of the other
	// handler is the same as this handler.
	Equals(other EventHandler) bool
}

EventHandler is the interface for an event handler. In JavaScript; an event handler can be a function; or an object with a `handleEvent` function. In Go code, you can provide your own implementation, or use NewEventHandlerFunc to create a valid handler from a function.

Multiple EventHandler instances can represent the same underlying event handler. E.g., when JavaScript code calls RemoveEventListener, a new Go struct is created wrapping the same underlying handler.

The Equals function must return true when the other event handler is the same as the current value, so event handlers can properly be removed, and avoiding duplicates are added by AddEventListener.

func NewEventHandlerFunc 

func NewEventHandlerFunc(handler HandlerFunc) EventHandler

NewEventHandlerFunc creates an EventHandler implementation from a compatible function.

Note: Calling this twice for the same Go-function will be treated as different event handlers. Be sure to use the same instance returned from this function when removing.

func NewEventHandlerFuncWithoutError 

func NewEventHandlerFuncWithoutError(handler HandlerFuncWithoutError) EventHandler

type EventOption 

type EventOption interface {
	// contains filtered or unexported methods
}

func EventBubbles 

func EventBubbles(bubbles bool) EventOption

func EventCancelable 

func EventCancelable(cancelable bool) EventOption

type EventOptions 

type EventOptions []EventOption

type EventTarget 

type EventTarget interface {
	AddEventListener(eventType string, listener EventHandler)
	RemoveEventListener(eventType string, listener EventHandler)
	DispatchEvent(event Event) bool
	// Adds a listener that will receive _all_ dispatched events. This listener
	// will not be removed from the window when navigating. This makes it useful
	// for a test to setup event listeners _before_ navigating, as by the time the
	// Navigate function returns, the DOMContentLoaded event _has_ fired, and
	// subscribed listeners have been called.
	SetCatchAllHandler(listener EventHandler)
	RemoveAll()
	// contains filtered or unexported methods
}

func NewEventTarget 

func NewEventTarget() EventTarget

type GetRootNodeOptions 

type GetRootNodeOptions bool

type HTMLCollection added in v0.2.0 

type HTMLCollection interface {
	Length() int
	Item(int) Element
	NamedItem(string) Element
}

type HandlerFunc 

type HandlerFunc = func(Event) error

type HandlerFuncWithoutError 

type HandlerFuncWithoutError = func(Event)

type MouseEvents 

type MouseEvents interface {
	Click() bool
}

type NamedNodeMap 

type NamedNodeMap interface {
	entity.Entity
	All() iter.Seq[Attr]
	Length() int
	Item(index int) Attr
}

type Node 

type Node interface {
	entity.Entity
	EventTarget
	AppendChild(node Node) (Node, error)
	GetRootNode(options ...GetRootNodeOptions) Node
	ChildNodes() NodeList
	CloneNode(deep bool) Node
	IsConnected() bool
	// IsSameNode shouldn't be used and may be removed in a future version.
	IsSameNode(Node) bool
	Contains(node Node) bool
	InsertBefore(newNode Node, referenceNode Node) (Node, error)
	NodeName() string
	NodeType() NodeType
	OwnerDocument() Document
	Parent() Node
	ParentElement() Element
	RemoveChild(node Node) (Node, error)
	NextSibling() Node
	PreviousSibling() Node
	FirstChild() Node
	TextContent() string
	SetTextContent(value string)
	Connected()
	// SetSelf must be called when creating instances of structs embedding a Node.
	//
	// If this is not called, the specialised type, which is itself a Node, will
	// not be returned from functions that should have returned it, e.g., through
	// ChildNodes. Only the embedded Node will be returned, and any specialised
	// behaviour, including HTML output, will not work.
	//
	// This function is a workaround to solve a fundamental problem. The DOM
	// specifies a model that is fundamentally object-oriented, with sub-classes
	// overriding behaviour in super-classes. This is not a behaviour that Go has.
	SetSelf(node Node)
	// contains filtered or unexported methods
}

type NodeList 

type NodeList interface {
	entity.Entity
	Length() int
	Item(index int) Node
	All() []Node
	// contains filtered or unexported methods
}

type NodeType 

type NodeType int
const (
	NodeTypeElement               NodeType = 1
	NodeTypeAttribute             NodeType = 2
	NodeTypeText                  NodeType = 3
	NodeTypeCDataSection          NodeType = 4
	NodeTypeProcessingInstruction NodeType = 7
	NodeTypeComment               NodeType = 8
	NodeTypeDocument              NodeType = 9
	NodeTypeDocumentType          NodeType = 10
	NodeTypeDocumentFragment      NodeType = 11
)

func (NodeType) String 

func (t NodeType) String() string

String returns name of the node type. For invalid values, a string representation of the integer value is returned.

type NotImplementedError 

type NotImplementedError error

type ParentNode added in v0.2.0 

type ParentNode interface {
	Children() HTMLCollection
	FirstElementChild() Element
	LastElementChild() Element
	ChildElementCount() int
	/*
	   Note that the IDL operation accepts either string or node values. This interface
	   requires an explicit a [Node]. Use [Document.CreateText] to convert a string to
	   a Node.

	   See also: https://developer.mozilla.org/en-US/docs/Web/API/Element
	*/
	Prepend(nodes ...Node) error
	/*
	   Note that the IDL operation accepts either string or node values. This interface
	   requires an explicit a [Node]. Use [Document.CreateText] to convert a string to
	   a Node.

	   See also: https://developer.mozilla.org/en-US/docs/Web/API/Element
	*/
	Append(nodes ...Node) error
	/*
	   Note that the IDL operation accepts either string or node values. This interface
	   requires an explicit a [Node]. Use [Document.CreateText] to convert a string to
	   a Node.

	   See also: https://developer.mozilla.org/en-US/docs/Web/API/Element
	*/
	ReplaceChildren(nodes ...Node) error
	QuerySelector(string) (Element, error)
	QuerySelectorAll(string) (NodeList, error)
}

type RootNode 

type RootNode interface {
	ElementContainer
	GetElementById(string) Element
}

RootNode implements defines common behaviour between Document and DocumentFragment. While they both have Node as the direct base class in the DOM spec; they share a common set of functions operating on elements.

type ShadowRoot 

type ShadowRoot interface {
	DocumentFragment
}

type Text 

type Text interface {
	CharacterData
}

func NewText 

func NewText(text string, ownerDocument Document) Text

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.