mirror of
https://github.com/nim-lang/Nim.git
synced 2025-12-29 09:24:36 +00:00
4bf0f846df
Doesn't exists anymore.
Use `window.localStorage.getItem("key").isNil` instead
1842 lines
54 KiB
Nim
1842 lines
54 KiB
Nim
#
|
|
#
|
|
# Nim's Runtime Library
|
|
# (c) Copyright 2012 Andreas Rumpf
|
|
#
|
|
# See the file "copying.txt", included in this
|
|
# distribution, for details about the copyright.
|
|
#
|
|
|
|
## Declaration of the Document Object Model for the `JavaScript backend
|
|
## <backends.html#backends-the-javascript-target>`_.
|
|
##
|
|
##
|
|
## Document Ready
|
|
## --------------
|
|
##
|
|
## * Basic example of a document ready:
|
|
runnableExamples"-b:js -r:off":
|
|
proc example(e: Event) = echo "Document is ready"
|
|
document.addEventListener("DOMContentLoaded", example) # You can also use "load" event.
|
|
## * This example runs 5 seconds after the document ready:
|
|
runnableExamples"-b:js -r:off":
|
|
proc example() = echo "5 seconds after document ready"
|
|
proc domReady(e: Event) = discard setTimeout(example, 5_000) # Document is ready.
|
|
document.addEventListener("DOMContentLoaded", domReady)
|
|
## Document onUnload
|
|
## -----------------
|
|
##
|
|
## * Simple example of how to implement code that runs when the page unloads:
|
|
runnableExamples"-b:js -r:off":
|
|
proc example(e: Event) = echo "Document is unloaded"
|
|
document.addEventListener("unload", example) # You can also use "beforeunload".
|
|
## Document Autorefresh
|
|
## --------------------
|
|
##
|
|
## * Minimal example of a document autorefresh:
|
|
runnableExamples"-b:js -r:off":
|
|
proc example() = window.location.reload()
|
|
discard setTimeout(example, 5_000)
|
|
## - For more examples, see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
|
|
|
|
|
|
import std/private/since
|
|
when not defined(js):
|
|
{.error: "This module only works on the JavaScript platform".}
|
|
|
|
const
|
|
DomApiVersion* = 3 ## the version of DOM API we try to follow. No guarantees though.
|
|
|
|
type
|
|
EventTarget* {.importc.} = ref object of RootObj
|
|
onabort*: proc (event: Event) {.closure.}
|
|
onblur*: proc (event: Event) {.closure.}
|
|
onchange*: proc (event: Event) {.closure.}
|
|
onclick*: proc (event: Event) {.closure.}
|
|
ondblclick*: proc (event: Event) {.closure.}
|
|
onerror*: proc (event: Event) {.closure.}
|
|
onfocus*: proc (event: Event) {.closure.}
|
|
onkeydown*: proc (event: Event) {.closure.}
|
|
onkeypress*: proc (event: Event) {.closure.}
|
|
onkeyup*: proc (event: Event) {.closure.}
|
|
onload*: proc (event: Event) {.closure.}
|
|
onmousedown*: proc (event: Event) {.closure.}
|
|
onmousemove*: proc (event: Event) {.closure.}
|
|
onmouseout*: proc (event: Event) {.closure.}
|
|
onmouseover*: proc (event: Event) {.closure.}
|
|
onmouseup*: proc (event: Event) {.closure.}
|
|
onreset*: proc (event: Event) {.closure.}
|
|
onselect*: proc (event: Event) {.closure.}
|
|
onstorage*: proc (event: Event) {.closure.}
|
|
onsubmit*: proc (event: Event) {.closure.}
|
|
onunload*: proc (event: Event) {.closure.}
|
|
onloadstart*: proc (event: Event) {.closure.}
|
|
onprogress*: proc (event: Event) {.closure.}
|
|
onloadend*: proc (event: Event) {.closure.}
|
|
|
|
DomEvent* {.pure.} = enum
|
|
## see `docs<https://developer.mozilla.org/en-US/docs/Web/Events>`_
|
|
Abort = "abort",
|
|
BeforeInput = "beforeinput",
|
|
Blur = "blur",
|
|
Click = "click",
|
|
CompositionEnd = "compositionend",
|
|
CompositionStart = "compositionstart",
|
|
CompositionUpdate = "compositionupdate",
|
|
DblClick = "dblclick",
|
|
Error = "error",
|
|
Focus = "focus",
|
|
FocusIn = "focusin",
|
|
FocusOut = "focusout",
|
|
Input = "input",
|
|
KeyDown = "keydown",
|
|
KeyPress = "keypress",
|
|
KeyUp = "keyup",
|
|
Load = "load",
|
|
MouseDown = "mousedown",
|
|
MouseEnter = "mouseenter",
|
|
MouseLeave = "mouseleave",
|
|
MouseMove = "mousemove",
|
|
MouseOut = "mouseout",
|
|
MouseOver = "mouseover",
|
|
MouseUp = "mouseup",
|
|
Resize = "resize",
|
|
Scroll = "scroll",
|
|
Select = "select",
|
|
Storage = "storage",
|
|
Unload = "unload",
|
|
Wheel = "wheel"
|
|
|
|
PerformanceMemory* {.importc.} = ref object
|
|
jsHeapSizeLimit*: float
|
|
totalJSHeapSize*: float
|
|
usedJSHeapSize*: float
|
|
|
|
PerformanceTiming* {.importc.} = ref object
|
|
connectStart*: float
|
|
domComplete*: float
|
|
domContentLoadedEventEnd*: float
|
|
domContentLoadedEventStart*: float
|
|
domInteractive*: float
|
|
domLoading*: float
|
|
domainLookupEnd*: float
|
|
domainLookupStart*: float
|
|
fetchStart*: float
|
|
loadEventEnd*: float
|
|
loadEventStart*: float
|
|
navigationStart*: float
|
|
redirectEnd*: float
|
|
redirectStart*: float
|
|
requestStart*: float
|
|
responseEnd*: float
|
|
responseStart*: float
|
|
secureConnectionStart*: float
|
|
unloadEventEnd*: float
|
|
unloadEventStart*: float
|
|
|
|
Performance* {.importc.} = ref object
|
|
memory*: PerformanceMemory
|
|
timing*: PerformanceTiming
|
|
|
|
Range* {.importc.} = ref object
|
|
## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/Range>`_
|
|
collapsed*: bool
|
|
commonAncestorContainer*: Node
|
|
endContainer*: Node
|
|
endOffset*: int
|
|
startContainer*: Node
|
|
startOffset*: int
|
|
|
|
Selection* {.importc.} = ref object
|
|
## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/Selection>`_
|
|
anchorNode*: Node
|
|
anchorOffset*: int
|
|
focusNode*: Node
|
|
focusOffset*: int
|
|
isCollapsed*: bool
|
|
rangeCount*: int
|
|
`type`*: cstring
|
|
|
|
Storage* {.importc.} = ref object
|
|
|
|
Window* {.importc.} = ref object of EventTarget
|
|
document*: Document
|
|
event*: Event
|
|
history*: History
|
|
location*: Location
|
|
closed*: bool
|
|
defaultStatus*: cstring
|
|
devicePixelRatio*: float
|
|
innerHeight*, innerWidth*: int
|
|
locationbar*: ref LocationBar
|
|
menubar*: ref MenuBar
|
|
name*: cstring
|
|
outerHeight*, outerWidth*: int
|
|
pageXOffset*, pageYOffset*: int
|
|
scrollX*: float
|
|
scrollY*: float
|
|
personalbar*: ref PersonalBar
|
|
scrollbars*: ref ScrollBars
|
|
statusbar*: ref StatusBar
|
|
status*: cstring
|
|
toolbar*: ref ToolBar
|
|
frames*: seq[Frame]
|
|
screen*: Screen
|
|
performance*: Performance
|
|
onpopstate*: proc (event: Event)
|
|
localStorage*: Storage
|
|
sessionStorage*: Storage
|
|
parent*: Window
|
|
|
|
Frame* {.importc.} = ref object of Window
|
|
|
|
ClassList* {.importc.} = ref object of RootObj
|
|
|
|
NodeType* = enum
|
|
ElementNode = 1,
|
|
AttributeNode,
|
|
TextNode,
|
|
CDATANode,
|
|
EntityRefNode,
|
|
EntityNode,
|
|
ProcessingInstructionNode,
|
|
CommentNode,
|
|
DocumentNode,
|
|
DocumentTypeNode,
|
|
DocumentFragmentNode,
|
|
NotationNode
|
|
|
|
Node* {.importc.} = ref object of EventTarget
|
|
attributes*: seq[Node]
|
|
childNodes*: seq[Node]
|
|
children*: seq[Node]
|
|
data*: cstring
|
|
firstChild*: Node
|
|
lastChild*: Node
|
|
nextSibling*: Node
|
|
nodeName*: cstring
|
|
nodeType*: NodeType
|
|
nodeValue*: cstring
|
|
parentNode*: Node
|
|
content*: Node
|
|
previousSibling*: Node
|
|
ownerDocument*: Document
|
|
innerHTML*: cstring
|
|
outerHTML*: cstring
|
|
innerText*: cstring
|
|
textContent*: cstring
|
|
style*: Style
|
|
baseURI*: cstring
|
|
parentElement*: Element
|
|
isConnected*: bool
|
|
|
|
Document* {.importc.} = ref object of Node
|
|
activeElement*: Element
|
|
documentElement*: Element
|
|
alinkColor*: cstring
|
|
bgColor*: cstring
|
|
body*: Element
|
|
charset*: cstring
|
|
cookie*: cstring
|
|
defaultCharset*: cstring
|
|
fgColor*: cstring
|
|
head*: Element
|
|
hidden*: bool
|
|
lastModified*: cstring
|
|
linkColor*: cstring
|
|
referrer*: cstring
|
|
title*: cstring
|
|
URL*: cstring
|
|
visibilityState*: cstring
|
|
vlinkColor*: cstring
|
|
anchors*: seq[AnchorElement]
|
|
forms*: seq[FormElement]
|
|
images*: seq[ImageElement]
|
|
applets*: seq[Element]
|
|
embeds*: seq[EmbedElement]
|
|
links*: seq[LinkElement]
|
|
fonts*: FontFaceSet
|
|
|
|
Element* {.importc.} = ref object of Node
|
|
className*: cstring
|
|
classList*: ClassList
|
|
checked*: bool
|
|
defaultChecked*: bool
|
|
defaultValue*: cstring
|
|
disabled*: bool
|
|
form*: FormElement
|
|
name*: cstring
|
|
readOnly*: bool
|
|
options*: seq[OptionElement]
|
|
selectedOptions*: seq[OptionElement]
|
|
clientWidth*, clientHeight*: int
|
|
contentEditable*: cstring
|
|
isContentEditable*: bool
|
|
dir*: cstring
|
|
offsetHeight*: int
|
|
offsetWidth*: int
|
|
offsetLeft*: int
|
|
offsetTop*: int
|
|
|
|
ValidityState* {.importc.} = ref object ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/ValidityState>`_
|
|
badInput*: bool
|
|
customError*: bool
|
|
patternMismatch*: bool
|
|
rangeOverflow*: bool
|
|
rangeUnderflow*: bool
|
|
stepMismatch*: bool
|
|
tooLong*: bool
|
|
tooShort*: bool
|
|
typeMismatch*: bool
|
|
valid*: bool
|
|
valueMissing*: bool
|
|
|
|
Blob* {.importc.} = ref object of RootObj ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/Blob>`_
|
|
size*: int
|
|
`type`*: cstring
|
|
|
|
File* {.importc.} = ref object of Blob ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/File>`_
|
|
lastModified*: int
|
|
name*: cstring
|
|
|
|
TextAreaElement* {.importc.} = ref object of Element ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement>`_
|
|
value*: cstring
|
|
selectionStart*, selectionEnd*: int
|
|
selectionDirection*: cstring
|
|
rows*, cols*: int
|
|
|
|
InputElement* {.importc.} = ref object of Element ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement>`_
|
|
# Properties related to the parent form
|
|
formAction*: cstring
|
|
formEncType*: cstring
|
|
formMethod*: cstring
|
|
formNoValidate*: bool
|
|
formTarget*: cstring
|
|
|
|
# Properties that apply to any type of input element that is not hidden
|
|
`type`*: cstring
|
|
autofocus*: bool
|
|
required*: bool
|
|
value*: cstring
|
|
validity*: ValidityState
|
|
validationMessage*: cstring
|
|
willValidate*: bool
|
|
|
|
# Properties that apply only to elements of type "checkbox" or "radio"
|
|
indeterminate*: bool
|
|
|
|
# Properties that apply only to elements of type "image"
|
|
alt*: cstring
|
|
height*: cstring
|
|
src*: cstring
|
|
width*: cstring
|
|
|
|
# Properties that apply only to elements of type "file"
|
|
accept*: cstring
|
|
files*: seq[Blob]
|
|
|
|
# Properties that apply only to text/number-containing or elements
|
|
autocomplete*: cstring
|
|
maxLength*: int
|
|
size*: int
|
|
pattern*: cstring
|
|
placeholder*: cstring
|
|
min*: cstring
|
|
max*: cstring
|
|
selectionStart*: int
|
|
selectionEnd*: int
|
|
selectionDirection*: cstring
|
|
|
|
# Properties not yet categorized
|
|
dirName*: cstring
|
|
accessKey*: cstring
|
|
list*: Element
|
|
multiple*: bool
|
|
labels*: seq[Element]
|
|
step*: cstring
|
|
valueAsDate*: cstring
|
|
valueAsNumber*: float
|
|
|
|
LinkElement* {.importc.} = ref object of Element
|
|
target*: cstring
|
|
text*: cstring
|
|
x*: int
|
|
y*: int
|
|
|
|
EmbedElement* {.importc.} = ref object of Element
|
|
height*: int
|
|
hspace*: int
|
|
src*: cstring
|
|
width*: int
|
|
`type`*: cstring
|
|
vspace*: int
|
|
|
|
AnchorElement* {.importc.} = ref object of Element
|
|
text*: cstring
|
|
x*, y*: int
|
|
|
|
OptionElement* {.importc.} = ref object of Element
|
|
defaultSelected*: bool
|
|
selected*: bool
|
|
selectedIndex*: int
|
|
text*: cstring
|
|
value*: cstring
|
|
|
|
FormElement* {.importc.} = ref object of Element ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement>`_
|
|
acceptCharset*: cstring
|
|
action*: cstring
|
|
autocomplete*: cstring
|
|
elements*: seq[Element]
|
|
encoding*: cstring
|
|
enctype*: cstring
|
|
length*: int
|
|
`method`*: cstring
|
|
noValidate*: bool
|
|
target*: cstring
|
|
|
|
ImageElement* {.importc.} = ref object of Element
|
|
border*: int
|
|
complete*: bool
|
|
height*: int
|
|
hspace*: int
|
|
lowsrc*: cstring
|
|
src*: cstring
|
|
vspace*: int
|
|
width*: int
|
|
|
|
Style* {.importc.} = ref object of RootObj
|
|
alignContent*: cstring
|
|
alignItems*: cstring
|
|
alignSelf*: cstring
|
|
all*: cstring
|
|
animation*: cstring
|
|
animationDelay*: cstring
|
|
animationDirection*: cstring
|
|
animationDuration*: cstring
|
|
animationFillMode*: cstring
|
|
animationIterationCount*: cstring
|
|
animationName*: cstring
|
|
animationPlayState*: cstring
|
|
animationTimingFunction*: cstring
|
|
backdropFilter*: cstring
|
|
backfaceVisibility*: cstring
|
|
background*: cstring
|
|
backgroundAttachment*: cstring
|
|
backgroundBlendMode*: cstring
|
|
backgroundClip*: cstring
|
|
backgroundColor*: cstring
|
|
backgroundImage*: cstring
|
|
backgroundOrigin*: cstring
|
|
backgroundPosition*: cstring
|
|
backgroundRepeat*: cstring
|
|
backgroundSize*: cstring
|
|
blockSize*: cstring
|
|
border*: cstring
|
|
borderBlock*: cstring
|
|
borderBlockColor*: cstring
|
|
borderBlockEnd*: cstring
|
|
borderBlockEndColor*: cstring
|
|
borderBlockEndStyle*: cstring
|
|
borderBlockEndWidth*: cstring
|
|
borderBlockStart*: cstring
|
|
borderBlockStartColor*: cstring
|
|
borderBlockStartStyle*: cstring
|
|
borderBlockStartWidth*: cstring
|
|
borderBlockStyle*: cstring
|
|
borderBlockWidth*: cstring
|
|
borderBottom*: cstring
|
|
borderBottomColor*: cstring
|
|
borderBottomLeftRadius*: cstring
|
|
borderBottomRightRadius*: cstring
|
|
borderBottomStyle*: cstring
|
|
borderBottomWidth*: cstring
|
|
borderCollapse*: cstring
|
|
borderColor*: cstring
|
|
borderEndEndRadius*: cstring
|
|
borderEndStartRadius*: cstring
|
|
borderImage*: cstring
|
|
borderImageOutset*: cstring
|
|
borderImageRepeat*: cstring
|
|
borderImageSlice*: cstring
|
|
borderImageSource*: cstring
|
|
borderImageWidth*: cstring
|
|
borderInline*: cstring
|
|
borderInlineColor*: cstring
|
|
borderInlineEnd*: cstring
|
|
borderInlineEndColor*: cstring
|
|
borderInlineEndStyle*: cstring
|
|
borderInlineEndWidth*: cstring
|
|
borderInlineStart*: cstring
|
|
borderInlineStartColor*: cstring
|
|
borderInlineStartStyle*: cstring
|
|
borderInlineStartWidth*: cstring
|
|
borderInlineStyle*: cstring
|
|
borderInlineWidth*: cstring
|
|
borderLeft*: cstring
|
|
borderLeftColor*: cstring
|
|
borderLeftStyle*: cstring
|
|
borderLeftWidth*: cstring
|
|
borderRadius*: cstring
|
|
borderRight*: cstring
|
|
borderRightColor*: cstring
|
|
borderRightStyle*: cstring
|
|
borderRightWidth*: cstring
|
|
borderSpacing*: cstring
|
|
borderStartEndRadius*: cstring
|
|
borderStartStartRadius*: cstring
|
|
borderStyle*: cstring
|
|
borderTop*: cstring
|
|
borderTopColor*: cstring
|
|
borderTopLeftRadius*: cstring
|
|
borderTopRightRadius*: cstring
|
|
borderTopStyle*: cstring
|
|
borderTopWidth*: cstring
|
|
borderWidth*: cstring
|
|
bottom*: cstring
|
|
boxDecorationBreak*: cstring
|
|
boxShadow*: cstring
|
|
boxSizing*: cstring
|
|
breakAfter*: cstring
|
|
breakBefore*: cstring
|
|
breakInside*: cstring
|
|
captionSide*: cstring
|
|
caretColor*: cstring
|
|
clear*: cstring
|
|
clip*: cstring
|
|
clipPath*: cstring
|
|
color*: cstring
|
|
colorAdjust*: cstring
|
|
columnCount*: cstring
|
|
columnFill*: cstring
|
|
columnGap*: cstring
|
|
columnRule*: cstring
|
|
columnRuleColor*: cstring
|
|
columnRuleStyle*: cstring
|
|
columnRuleWidth*: cstring
|
|
columnSpan*: cstring
|
|
columnWidth*: cstring
|
|
columns*: cstring
|
|
contain*: cstring
|
|
content*: cstring
|
|
counterIncrement*: cstring
|
|
counterReset*: cstring
|
|
counterSet*: cstring
|
|
cursor*: cstring
|
|
direction*: cstring
|
|
display*: cstring
|
|
emptyCells*: cstring
|
|
filter*: cstring
|
|
flex*: cstring
|
|
flexBasis*: cstring
|
|
flexDirection*: cstring
|
|
flexFlow*: cstring
|
|
flexGrow*: cstring
|
|
flexShrink*: cstring
|
|
flexWrap*: cstring
|
|
cssFloat*: cstring
|
|
font*: cstring
|
|
fontFamily*: cstring
|
|
fontFeatureSettings*: cstring
|
|
fontKerning*: cstring
|
|
fontLanguageOverride*: cstring
|
|
fontOpticalSizing*: cstring
|
|
fontSize*: cstring
|
|
fontSizeAdjust*: cstring
|
|
fontStretch*: cstring
|
|
fontStyle*: cstring
|
|
fontSynthesis*: cstring
|
|
fontVariant*: cstring
|
|
fontVariantAlternates*: cstring
|
|
fontVariantCaps*: cstring
|
|
fontVariantEastAsian*: cstring
|
|
fontVariantLigatures*: cstring
|
|
fontVariantNumeric*: cstring
|
|
fontVariantPosition*: cstring
|
|
fontVariationSettings*: cstring
|
|
fontWeight*: cstring
|
|
gap*: cstring
|
|
grid*: cstring
|
|
gridArea*: cstring
|
|
gridAutoColumns*: cstring
|
|
gridAutoFlow*: cstring
|
|
gridAutoRows*: cstring
|
|
gridColumn*: cstring
|
|
gridColumnEnd*: cstring
|
|
gridColumnStart*: cstring
|
|
gridRow*: cstring
|
|
gridRowEnd*: cstring
|
|
gridRowStart*: cstring
|
|
gridTemplate*: cstring
|
|
gridTemplateAreas*: cstring
|
|
gridTemplateColumns*: cstring
|
|
gridTemplateRows*: cstring
|
|
hangingPunctuation*: cstring
|
|
height*: cstring
|
|
hyphens*: cstring
|
|
imageOrientation*: cstring
|
|
imageRendering*: cstring
|
|
inlineSize*: cstring
|
|
inset*: cstring
|
|
insetBlock*: cstring
|
|
insetBlockEnd*: cstring
|
|
insetBlockStart*: cstring
|
|
insetInline*: cstring
|
|
insetInlineEnd*: cstring
|
|
insetInlineStart*: cstring
|
|
isolation*: cstring
|
|
justifyContent*: cstring
|
|
justifyItems*: cstring
|
|
justifySelf*: cstring
|
|
left*: cstring
|
|
letterSpacing*: cstring
|
|
lineBreak*: cstring
|
|
lineHeight*: cstring
|
|
listStyle*: cstring
|
|
listStyleImage*: cstring
|
|
listStylePosition*: cstring
|
|
listStyleType*: cstring
|
|
margin*: cstring
|
|
marginBlock*: cstring
|
|
marginBlockEnd*: cstring
|
|
marginBlockStart*: cstring
|
|
marginBottom*: cstring
|
|
marginInline*: cstring
|
|
marginInlineEnd*: cstring
|
|
marginInlineStart*: cstring
|
|
marginLeft*: cstring
|
|
marginRight*: cstring
|
|
marginTop*: cstring
|
|
mask*: cstring
|
|
maskBorder*: cstring
|
|
maskBorderMode*: cstring
|
|
maskBorderOutset*: cstring
|
|
maskBorderRepeat*: cstring
|
|
maskBorderSlice*: cstring
|
|
maskBorderSource*: cstring
|
|
maskBorderWidth*: cstring
|
|
maskClip*: cstring
|
|
maskComposite*: cstring
|
|
maskImage*: cstring
|
|
maskMode*: cstring
|
|
maskOrigin*: cstring
|
|
maskPosition*: cstring
|
|
maskRepeat*: cstring
|
|
maskSize*: cstring
|
|
maskType*: cstring
|
|
maxBlockSize*: cstring
|
|
maxHeight*: cstring
|
|
maxInlineSize*: cstring
|
|
maxWidth*: cstring
|
|
minBlockSize*: cstring
|
|
minHeight*: cstring
|
|
minInlineSize*: cstring
|
|
minWidth*: cstring
|
|
mixBlendMode*: cstring
|
|
objectFit*: cstring
|
|
objectPosition*: cstring
|
|
offset*: cstring
|
|
offsetAnchor*: cstring
|
|
offsetDistance*: cstring
|
|
offsetPath*: cstring
|
|
offsetRotate*: cstring
|
|
opacity*: cstring
|
|
order*: cstring
|
|
orphans*: cstring
|
|
outline*: cstring
|
|
outlineColor*: cstring
|
|
outlineOffset*: cstring
|
|
outlineStyle*: cstring
|
|
outlineWidth*: cstring
|
|
overflow*: cstring
|
|
overflowAnchor*: cstring
|
|
overflowBlock*: cstring
|
|
overflowInline*: cstring
|
|
overflowWrap*: cstring
|
|
overflowX*: cstring
|
|
overflowY*: cstring
|
|
overscrollBehavior*: cstring
|
|
overscrollBehaviorBlock*: cstring
|
|
overscrollBehaviorInline*: cstring
|
|
overscrollBehaviorX*: cstring
|
|
overscrollBehaviorY*: cstring
|
|
padding*: cstring
|
|
paddingBlock*: cstring
|
|
paddingBlockEnd*: cstring
|
|
paddingBlockStart*: cstring
|
|
paddingBottom*: cstring
|
|
paddingInline*: cstring
|
|
paddingInlineEnd*: cstring
|
|
paddingInlineStart*: cstring
|
|
paddingLeft*: cstring
|
|
paddingRight*: cstring
|
|
paddingTop*: cstring
|
|
pageBreakAfter*: cstring
|
|
pageBreakBefore*: cstring
|
|
pageBreakInside*: cstring
|
|
paintOrder*: cstring
|
|
perspective*: cstring
|
|
perspectiveOrigin*: cstring
|
|
placeContent*: cstring
|
|
placeItems*: cstring
|
|
placeSelf*: cstring
|
|
pointerEvents*: cstring
|
|
position*: cstring
|
|
quotes*: cstring
|
|
resize*: cstring
|
|
right*: cstring
|
|
rotate*: cstring
|
|
rowGap*: cstring
|
|
scale*: cstring
|
|
scrollBehavior*: cstring
|
|
scrollMargin*: cstring
|
|
scrollMarginBlock*: cstring
|
|
scrollMarginBlockEnd*: cstring
|
|
scrollMarginBlockStart*: cstring
|
|
scrollMarginBottom*: cstring
|
|
scrollMarginInline*: cstring
|
|
scrollMarginInlineEnd*: cstring
|
|
scrollMarginInlineStart*: cstring
|
|
scrollMarginLeft*: cstring
|
|
scrollMarginRight*: cstring
|
|
scrollMarginTop*: cstring
|
|
scrollPadding*: cstring
|
|
scrollPaddingBlock*: cstring
|
|
scrollPaddingBlockEnd*: cstring
|
|
scrollPaddingBlockStart*: cstring
|
|
scrollPaddingBottom*: cstring
|
|
scrollPaddingInline*: cstring
|
|
scrollPaddingInlineEnd*: cstring
|
|
scrollPaddingInlineStart*: cstring
|
|
scrollPaddingLeft*: cstring
|
|
scrollPaddingRight*: cstring
|
|
scrollPaddingTop*: cstring
|
|
scrollSnapAlign*: cstring
|
|
scrollSnapStop*: cstring
|
|
scrollSnapType*: cstring
|
|
scrollbar3dLightColor*: cstring
|
|
scrollbarArrowColor*: cstring
|
|
scrollbarBaseColor*: cstring
|
|
scrollbarColor*: cstring
|
|
scrollbarDarkshadowColor*: cstring
|
|
scrollbarFaceColor*: cstring
|
|
scrollbarHighlightColor*: cstring
|
|
scrollbarShadowColor*: cstring
|
|
scrollbarTrackColor*: cstring
|
|
scrollbarWidth*: cstring
|
|
shapeImageThreshold*: cstring
|
|
shapeMargin*: cstring
|
|
shapeOutside*: cstring
|
|
tabSize*: cstring
|
|
tableLayout*: cstring
|
|
textAlign*: cstring
|
|
textAlignLast*: cstring
|
|
textCombineUpright*: cstring
|
|
textDecoration*: cstring
|
|
textDecorationColor*: cstring
|
|
textDecorationLine*: cstring
|
|
textDecorationSkipInk*: cstring
|
|
textDecorationStyle*: cstring
|
|
textDecorationThickness*: cstring
|
|
textEmphasis*: cstring
|
|
textEmphasisColor*: cstring
|
|
textEmphasisPosition*: cstring
|
|
textEmphasisStyle*: cstring
|
|
textIndent*: cstring
|
|
textJustify*: cstring
|
|
textOrientation*: cstring
|
|
textOverflow*: cstring
|
|
textRendering*: cstring
|
|
textShadow*: cstring
|
|
textTransform*: cstring
|
|
textUnderlineOffset*: cstring
|
|
textUnderlinePosition*: cstring
|
|
top*: cstring
|
|
touchAction*: cstring
|
|
transform*: cstring
|
|
transformBox*: cstring
|
|
transformOrigin*: cstring
|
|
transformStyle*: cstring
|
|
transition*: cstring
|
|
transitionDelay*: cstring
|
|
transitionDuration*: cstring
|
|
transitionProperty*: cstring
|
|
transitionTimingFunction*: cstring
|
|
translate*: cstring
|
|
unicodeBidi*: cstring
|
|
verticalAlign*: cstring
|
|
visibility*: cstring
|
|
whiteSpace*: cstring
|
|
widows*: cstring
|
|
width*: cstring
|
|
willChange*: cstring
|
|
wordBreak*: cstring
|
|
wordSpacing*: cstring
|
|
writingMode*: cstring
|
|
zIndex*: cstring
|
|
|
|
EventPhase* = enum
|
|
None = 0,
|
|
CapturingPhase,
|
|
AtTarget,
|
|
BubblingPhase
|
|
|
|
Event* {.importc.} = ref object of RootObj ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/Event>`_
|
|
bubbles*: bool
|
|
cancelBubble*: bool
|
|
cancelable*: bool
|
|
composed*: bool
|
|
currentTarget*: Node
|
|
defaultPrevented*: bool
|
|
eventPhase*: int
|
|
target*: Node
|
|
`type`*: cstring
|
|
isTrusted*: bool
|
|
|
|
UIEvent* {.importc.} = ref object of Event ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/UIEvent>`_
|
|
detail*: int64
|
|
view*: Window
|
|
|
|
KeyboardEvent* {.importc.} = ref object of UIEvent ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent>`_
|
|
altKey*, ctrlKey*, metaKey*, shiftKey*: bool
|
|
code*: cstring
|
|
isComposing*: bool
|
|
key*: cstring
|
|
keyCode*: int
|
|
location*: int
|
|
|
|
KeyboardEventKey* {.pure.} = enum ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values>`_
|
|
# Modifier keys
|
|
Alt,
|
|
AltGraph,
|
|
CapsLock,
|
|
Control,
|
|
Fn,
|
|
FnLock,
|
|
Hyper,
|
|
Meta,
|
|
NumLock,
|
|
ScrollLock,
|
|
Shift,
|
|
Super,
|
|
Symbol,
|
|
SymbolLock,
|
|
|
|
# Whitespace keys
|
|
ArrowDown,
|
|
ArrowLeft,
|
|
ArrowRight,
|
|
ArrowUp,
|
|
End,
|
|
Home,
|
|
PageDown,
|
|
PageUp,
|
|
|
|
# Editing keys
|
|
Backspace,
|
|
Clear,
|
|
Copy,
|
|
CrSel,
|
|
Cut,
|
|
Delete,
|
|
EraseEof,
|
|
ExSel,
|
|
Insert,
|
|
Paste,
|
|
Redo,
|
|
Undo,
|
|
|
|
# UI keys
|
|
Accept,
|
|
Again,
|
|
Attn,
|
|
Cancel,
|
|
ContextMenu,
|
|
Escape,
|
|
Execute,
|
|
Find,
|
|
Finish,
|
|
Help,
|
|
Pause,
|
|
Play,
|
|
Props,
|
|
Select,
|
|
ZoomIn,
|
|
ZoomOut,
|
|
|
|
# Device keys
|
|
BrigtnessDown,
|
|
BrigtnessUp,
|
|
Eject,
|
|
LogOff,
|
|
Power,
|
|
PowerOff,
|
|
PrintScreen,
|
|
Hibernate,
|
|
Standby,
|
|
WakeUp,
|
|
|
|
# Common IME keys
|
|
AllCandidates,
|
|
Alphanumeric,
|
|
CodeInput,
|
|
Compose,
|
|
Convert,
|
|
Dead,
|
|
FinalMode,
|
|
GroupFirst,
|
|
GroupLast,
|
|
GroupNext,
|
|
GroupPrevious,
|
|
ModeChange,
|
|
NextCandidate,
|
|
NonConvert,
|
|
PreviousCandidate,
|
|
Process,
|
|
SingleCandidate,
|
|
|
|
# Korean keyboards only
|
|
HangulMode,
|
|
HanjaMode,
|
|
JunjaMode,
|
|
|
|
# Japanese keyboards only
|
|
Eisu,
|
|
Hankaku,
|
|
Hiragana,
|
|
HiraganaKatakana,
|
|
KanaMode,
|
|
KanjiMode,
|
|
Katakana,
|
|
Romaji,
|
|
Zenkaku,
|
|
ZenkakuHanaku,
|
|
|
|
# Function keys
|
|
F1,
|
|
F2,
|
|
F3,
|
|
F4,
|
|
F5,
|
|
F6,
|
|
F7,
|
|
F8,
|
|
F9,
|
|
F10,
|
|
F11,
|
|
F12,
|
|
F13,
|
|
F14,
|
|
F15,
|
|
F16,
|
|
F17,
|
|
F18,
|
|
F19,
|
|
F20,
|
|
Soft1,
|
|
Soft2,
|
|
Soft3,
|
|
Soft4,
|
|
|
|
# Phone keys
|
|
AppSwitch,
|
|
Call,
|
|
Camera,
|
|
CameraFocus,
|
|
EndCall,
|
|
GoBack,
|
|
GoHome,
|
|
HeadsetHook,
|
|
LastNumberRedial,
|
|
Notification,
|
|
MannerMode,
|
|
VoiceDial,
|
|
|
|
# Multimedia keys
|
|
ChannelDown,
|
|
ChannelUp,
|
|
MediaFastForward,
|
|
MediaPause,
|
|
MediaPlay,
|
|
MediaPlayPause,
|
|
MediaRecord,
|
|
MediaRewind,
|
|
MediaStop,
|
|
MediaTrackNext,
|
|
MediaTrackPrevious,
|
|
|
|
# Audio control keys
|
|
AudioBalanceLeft,
|
|
AudioBalanceRight,
|
|
AudioBassDown,
|
|
AudioBassBoostDown,
|
|
AudioBassBoostToggle,
|
|
AudioBassBoostUp,
|
|
AudioBassUp,
|
|
AudioFaderFront,
|
|
AudioFaderRear,
|
|
AudioSurroundModeNext,
|
|
AudioTrebleDown,
|
|
AudioTrebleUp,
|
|
AudioVolumeDown,
|
|
AUdioVolumeMute,
|
|
AudioVolumeUp,
|
|
MicrophoneToggle,
|
|
MicrophoneVolumeDown,
|
|
MicrophoneVolumeMute,
|
|
MicrophoneVolumeUp,
|
|
|
|
# TV control keys
|
|
TV,
|
|
TV3DMode,
|
|
TVAntennaCable,
|
|
TVAudioDescription,
|
|
TVAudioDescriptionMixDown,
|
|
TVAudioDescriptionMixUp,
|
|
TVContentsMenu,
|
|
TVDataService,
|
|
TVInput,
|
|
TVInputComponent1,
|
|
TVInputComponent2,
|
|
TVInputComposite1,
|
|
TVInputComposite2,
|
|
TVInputHDMI1,
|
|
TVInputHDMI2,
|
|
TVInputHDMI3,
|
|
TVInputHDMI4,
|
|
TVInputVGA1,
|
|
TVMediaContext,
|
|
TVNetwork,
|
|
TVNumberEntry,
|
|
TVPower,
|
|
TVRadioService,
|
|
TVSatellite,
|
|
TVSatelliteBS,
|
|
TVSatelliteCS,
|
|
TVSatelliteToggle,
|
|
TVTerrestrialAnalog,
|
|
TVTerrestrialDigital,
|
|
TVTimer,
|
|
|
|
# Media controller keys
|
|
AVRInput,
|
|
AVRPower,
|
|
ColorF0Red,
|
|
ColorF1Green,
|
|
ColorF2Yellow,
|
|
ColorF3Blue,
|
|
ColorF4Grey,
|
|
ColorF5Brown,
|
|
ClosedCaptionToggle,
|
|
Dimmer,
|
|
DisplaySwap,
|
|
DVR,
|
|
Exit,
|
|
FavoriteClear0,
|
|
FavoriteClear1,
|
|
FavoriteClear2,
|
|
FavoriteClear3,
|
|
FavoriteRecall0,
|
|
FavoriteRecall1,
|
|
FavoriteRecall2,
|
|
FavoriteRecall3,
|
|
FavoriteStore0,
|
|
FavoriteStore1,
|
|
FavoriteStore2,
|
|
FavoriteStore3,
|
|
Guide,
|
|
GuideNextDay,
|
|
GuidePreviousDay,
|
|
Info,
|
|
InstantReplay,
|
|
Link,
|
|
ListProgram,
|
|
LiveContent,
|
|
Lock,
|
|
MediaApps,
|
|
MediaAudioTrack,
|
|
MediaLast,
|
|
MediaSkipBackward,
|
|
MediaSkipForward,
|
|
MediaStepBackward,
|
|
MediaStepForward,
|
|
MediaTopMenu,
|
|
NavigateIn,
|
|
NavigateNext,
|
|
NavigateOut,
|
|
NavigatePrevious,
|
|
NextFavoriteChannel,
|
|
NextUserProfile,
|
|
OnDemand,
|
|
Pairing,
|
|
PinPDown,
|
|
PinPMove,
|
|
PinPUp,
|
|
PlaySpeedDown,
|
|
PlaySpeedReset,
|
|
PlaySpeedUp,
|
|
RandomToggle,
|
|
RcLowBattery,
|
|
RecordSpeedNext,
|
|
RfBypass,
|
|
ScanChannelsToggle,
|
|
ScreenModeNext,
|
|
Settings,
|
|
SplitScreenToggle,
|
|
STBInput,
|
|
STBPower,
|
|
Subtitle,
|
|
Teletext,
|
|
VideoModeNext,
|
|
Wink,
|
|
ZoomToggle,
|
|
|
|
# Speech recognition keys
|
|
SpeechCorrectionList,
|
|
SpeechInputToggle,
|
|
|
|
# Document keys
|
|
Close,
|
|
New,
|
|
Open,
|
|
Print,
|
|
Save,
|
|
SpellCheck,
|
|
MailForward,
|
|
MailReply,
|
|
MailSend,
|
|
|
|
# Application selector keys
|
|
LaunchCalculator,
|
|
LaunchCalendar,
|
|
LaunchContacts,
|
|
LaunchMail,
|
|
LaunchMediaPlayer,
|
|
LaunchMusicPlayer,
|
|
LaunchMyComputer,
|
|
LaunchPhone,
|
|
LaunchScreenSaver,
|
|
LaunchSpreadsheet,
|
|
LaunchWebBrowser,
|
|
LaunchWebCam,
|
|
LaunchWordProcessor,
|
|
LaunchApplication1,
|
|
LaunchApplication2,
|
|
LaunchApplication3,
|
|
LaunchApplication4,
|
|
LaunchApplication5,
|
|
LaunchApplication6,
|
|
LaunchApplication7,
|
|
LaunchApplication8,
|
|
LaunchApplication9,
|
|
LaunchApplication10,
|
|
LaunchApplication11,
|
|
LaunchApplication12,
|
|
LaunchApplication13,
|
|
LaunchApplication14,
|
|
LaunchApplication15,
|
|
LaunchApplication16,
|
|
|
|
# Browser control keys
|
|
BrowserBack,
|
|
BrowserFavorites,
|
|
BrowserForward,
|
|
BrowserHome,
|
|
BrowserRefresh,
|
|
BrowserSearch,
|
|
BrowserStop,
|
|
|
|
# Numeric keypad keys
|
|
Key11,
|
|
Key12,
|
|
Separator
|
|
|
|
MouseButtons* = enum
|
|
NoButton = 0,
|
|
PrimaryButton = 1,
|
|
SecondaryButton = 2,
|
|
AuxilaryButton = 4,
|
|
FourthButton = 8,
|
|
FifthButton = 16
|
|
|
|
MouseEvent* {.importc.} = ref object of UIEvent ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent>`_
|
|
altKey*, ctrlKey*, metaKey*, shiftKey*: bool
|
|
button*: int
|
|
buttons*: int
|
|
clientX*, clientY*: int
|
|
movementX*, movementY*: int
|
|
offsetX*, offsetY*: int
|
|
pageX*, pageY*: int
|
|
relatedTarget*: EventTarget
|
|
#region*: cstring
|
|
screenX*, screenY*: int
|
|
x*, y*: int
|
|
|
|
DataTransferItemKind* {.pure.} = enum
|
|
File = "file",
|
|
String = "string"
|
|
|
|
DataTransferItem* {.importc.} = ref object of RootObj ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem>`_
|
|
kind*: cstring
|
|
`type`*: cstring
|
|
|
|
DataTransfer* {.importc.} = ref object of RootObj ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer>`_
|
|
dropEffect*: cstring
|
|
effectAllowed*: cstring
|
|
files*: seq[Element]
|
|
items*: seq[DataTransferItem]
|
|
types*: seq[cstring]
|
|
|
|
DataTransferDropEffect* {.pure.} = enum
|
|
None = "none",
|
|
Copy = "copy",
|
|
Link = "link",
|
|
Move = "move"
|
|
|
|
DataTransferEffectAllowed* {.pure.} = enum
|
|
None = "none",
|
|
Copy = "copy",
|
|
CopyLink = "copyLink",
|
|
CopyMove = "copyMove",
|
|
Link = "link",
|
|
LinkMove = "linkMove",
|
|
Move = "move",
|
|
All = "all",
|
|
Uninitialized = "uninitialized"
|
|
|
|
DragEventTypes* = enum
|
|
Drag = "drag",
|
|
DragEnd = "dragend",
|
|
DragEnter = "dragenter",
|
|
DragExit = "dragexit",
|
|
DragLeave = "dragleave",
|
|
DragOver = "dragover",
|
|
DragStart = "dragstart",
|
|
Drop = "drop"
|
|
|
|
DragEvent* {.importc.} = object of MouseEvent
|
|
## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/DragEvent>`_
|
|
dataTransfer*: DataTransfer
|
|
|
|
ClipboardEvent* {.importc.} = object of Event
|
|
## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent>`_
|
|
clipboardData*: DataTransfer
|
|
|
|
StorageEvent* {.importc.} = ref object of Event ## see `docs<https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent>`_
|
|
key*: cstring
|
|
newValue*, oldValue*: cstring
|
|
storageArea*: Storage
|
|
url*: cstring
|
|
|
|
TouchList* {.importc.} = ref object of RootObj
|
|
length*: int
|
|
|
|
Touch* {.importc.} = ref object of RootObj
|
|
identifier*: int
|
|
screenX*, screenY*, clientX*, clientY*, pageX*, pageY*: int
|
|
target*: Element
|
|
radiusX*, radiusY*: int
|
|
rotationAngle*: int
|
|
force*: float
|
|
|
|
TouchEvent* {.importc.} = ref object of UIEvent
|
|
changedTouches*, targetTouches*, touches*: seq[Touch]
|
|
|
|
Location* {.importc.} = ref object of RootObj
|
|
hash*: cstring
|
|
host*: cstring
|
|
hostname*: cstring
|
|
href*: cstring
|
|
pathname*: cstring
|
|
port*: cstring
|
|
protocol*: cstring
|
|
search*: cstring
|
|
origin*: cstring
|
|
|
|
History* {.importc.} = ref object of RootObj
|
|
length*: int
|
|
|
|
Navigator* {.importc.} = ref object of RootObj
|
|
appCodeName*: cstring
|
|
appName*: cstring
|
|
appVersion*: cstring
|
|
buildID*: cstring ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/buildID
|
|
cookieEnabled*: bool
|
|
deviceMemory*: float ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/deviceMemory
|
|
doNotTrack*: cstring ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/doNotTrack
|
|
language*: cstring
|
|
languages*: seq[cstring] ## https://developer.mozilla.org/en-US/docs/Web/API/NavigatorLanguage/languages
|
|
maxTouchPoints*: cint ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/maxTouchPoints
|
|
onLine*: bool ## https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine
|
|
oscpu*: cstring ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/oscpu
|
|
platform*: cstring
|
|
userAgent*: cstring
|
|
vendor*: cstring ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/vendor
|
|
webdriver*: bool ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/webdriver
|
|
mimeTypes*: seq[ref MimeType]
|
|
|
|
Plugin* {.importc.} = object of RootObj
|
|
description*: cstring
|
|
filename*: cstring
|
|
name*: cstring
|
|
|
|
MimeType* {.importc.} = object of RootObj
|
|
description*: cstring
|
|
enabledPlugin*: ref Plugin
|
|
suffixes*: seq[cstring]
|
|
`type`*: cstring
|
|
|
|
LocationBar* {.importc.} = object of RootObj
|
|
visible*: bool
|
|
MenuBar* = LocationBar
|
|
PersonalBar* = LocationBar
|
|
ScrollBars* = LocationBar
|
|
ToolBar* = LocationBar
|
|
StatusBar* = LocationBar
|
|
|
|
Screen* {.importc.} = ref object of RootObj
|
|
availHeight*: int
|
|
availWidth*: int
|
|
colorDepth*: int
|
|
height*: int
|
|
pixelDepth*: int
|
|
width*: int
|
|
|
|
TimeOut* {.importc.} = ref object of RootObj
|
|
Interval* {.importc.} = ref object of RootObj
|
|
|
|
AddEventListenerOptions* = object
|
|
capture*: bool
|
|
once*: bool
|
|
passive*: bool
|
|
|
|
FontFaceSetReady* {.importc.} = ref object
|
|
## see: `docs<https://developer.mozilla.org/en-US/docs/Web/API/FontFaceSet/ready>`_
|
|
then*: proc(cb: proc())
|
|
|
|
FontFaceSet* {.importc.} = ref object
|
|
## see: `docs<https://developer.mozilla.org/en-US/docs/Web/API/FontFaceSet>`_
|
|
ready*: FontFaceSetReady
|
|
onloadingdone*: proc(event: Event)
|
|
|
|
ScrollIntoViewOptions* = object
|
|
behavior*: cstring
|
|
`block`*: cstring
|
|
inline*: cstring
|
|
|
|
MediaQueryList* {.importc.} = ref object of EventTarget
|
|
matches*: bool
|
|
media*: cstring
|
|
|
|
since (1, 3):
|
|
type
|
|
DomParser* = ref object
|
|
## DOM Parser object (defined on browser only, may not be on NodeJS).
|
|
## * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
|
|
##
|
|
## ```nim
|
|
## let prsr = newDomParser()
|
|
## discard prsr.parseFromString("<html><marquee>Hello World</marquee></html>".cstring, "text/html".cstring)
|
|
## ```
|
|
|
|
DomException* {.importc.} = ref object
|
|
## The DOMException interface represents an abnormal event (called an exception)
|
|
## which occurs as a result of calling a method or accessing a property of a web API.
|
|
## Each exception has a name, which is a short "CamelCase" style string identifying
|
|
## the error or abnormal condition.
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/DOMException
|
|
|
|
FileReader* {.importc.} = ref object of EventTarget
|
|
## The FileReader object lets web applications asynchronously read the contents of files
|
|
## (or raw data buffers) stored on the user's computer, using File or Blob objects to specify
|
|
## the file or data to read.
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader
|
|
|
|
FileReaderState* = distinct range[0'u16..2'u16]
|
|
RootNodeOptions* = object of RootObj
|
|
composed*: bool
|
|
DocumentOrShadowRoot* {.importc.} = object of RootObj
|
|
activeElement*: Element
|
|
# styleSheets*: StyleSheetList
|
|
ShadowRoot* {.importc.} = ref object of DocumentOrShadowRoot
|
|
delegatesFocus*: bool
|
|
host*: Element
|
|
innerHTML*: cstring
|
|
mode*: cstring # "open" or "closed"
|
|
ShadowRootInit* = object of RootObj
|
|
mode*: cstring
|
|
delegatesFocus*: bool
|
|
|
|
HTMLSlotElement* {.importc.} = ref object of RootObj
|
|
name*: cstring
|
|
SlotOptions* = object of RootObj
|
|
flatten*: bool
|
|
|
|
const
|
|
fileReaderEmpty* = 0.FileReaderState
|
|
fileReaderLoading* = 1.FileReaderState
|
|
fileReaderDone* = 2.FileReaderState
|
|
|
|
proc id*(n: Node): cstring {.importcpp: "#.id", nodecl.}
|
|
proc `id=`*(n: Node; x: cstring) {.importcpp: "#.id = #", nodecl.}
|
|
proc class*(n: Node): cstring {.importcpp: "#.className", nodecl.}
|
|
proc `class=`*(n: Node; v: cstring) {.importcpp: "#.className = #", nodecl.}
|
|
|
|
proc value*(n: Node): cstring {.importcpp: "#.value", nodecl.}
|
|
proc `value=`*(n: Node; v: cstring) {.importcpp: "#.value = #", nodecl.}
|
|
|
|
proc checked*(n: Node): bool {.importcpp: "#.checked", nodecl.}
|
|
proc `checked=`*(n: Node; v: bool) {.importcpp: "#.checked = #", nodecl.}
|
|
|
|
proc `disabled=`*(n: Node; v: bool) {.importcpp: "#.disabled = #", nodecl.}
|
|
|
|
when defined(nodejs):
|
|
# we provide a dummy DOM for nodejs for testing purposes
|
|
proc len*(x: Node): int = x.childNodes.len
|
|
proc `[]`*(x: Node; idx: int): Element =
|
|
assert idx >= 0 and idx < x.childNodes.len
|
|
result = cast[Element](x.childNodes[idx])
|
|
|
|
var document* = Document(nodeType: DocumentNode)
|
|
document.ownerDocument = document
|
|
|
|
proc getElem(x: Element; id: cstring): Element =
|
|
if x.id == id: return x
|
|
for i in 0..<x.len:
|
|
result = getElem(x[i], id)
|
|
if result != nil: return result
|
|
|
|
proc getElementById*(doc: Document; id: cstring): Element =
|
|
getElem(doc.body, id)
|
|
proc getElementById*(id: cstring): Element = document.getElementById(id)
|
|
|
|
proc appendChild*(parent, n: Node) =
|
|
n.parentNode = parent
|
|
n.ownerDocument = parent.ownerDocument
|
|
parent.childNodes.add n
|
|
|
|
proc replaceChild*(parent, newNode, oldNode: Node) =
|
|
newNode.parentNode = parent
|
|
oldNode.parentNode = nil
|
|
var i = 0
|
|
while i < parent.len:
|
|
if Node(parent[i]) == oldNode:
|
|
parent.childNodes[i] = newNode
|
|
return
|
|
inc i
|
|
raiseAssert "old node not in node list"
|
|
|
|
proc removeChild*(parent, child: Node) =
|
|
child.parentNode = nil
|
|
var i = 0
|
|
while i < parent.len:
|
|
if Node(parent[i]) == child:
|
|
parent.childNodes.delete(i)
|
|
return
|
|
inc i
|
|
raiseAssert "old node not in node list"
|
|
|
|
proc insertBefore*(parent, newNode, before: Node) =
|
|
appendChild(parent, newNode)
|
|
var i = 0
|
|
while i < parent.len-1:
|
|
if Node(parent[i]) == before:
|
|
for j in countdown(parent.len-1, i-1):
|
|
parent.childNodes[j] = parent.childNodes[j-1]
|
|
parent.childNodes[i-1] = newNode
|
|
return
|
|
inc i
|
|
#raiseAssert "before not in node list"
|
|
|
|
proc createElement*(d: Document, identifier: cstring): Element =
|
|
new(result)
|
|
result.nodeName = identifier
|
|
result.nodeType = NodeType.ElementNode
|
|
|
|
proc createTextNode*(d: Document, identifier: cstring): Node =
|
|
new(result)
|
|
result.nodeName = "#text"
|
|
result.nodeValue = identifier
|
|
result.nodeType = NodeType.TextNode
|
|
|
|
proc createComment*(d: Document, data: cstring): Node =
|
|
new(result)
|
|
result.nodeName = "#comment"
|
|
result.nodeValue = data
|
|
result.nodeType = NodeType.CommentNode
|
|
|
|
else:
|
|
proc len*(x: Node): int {.importcpp: "#.childNodes.length".}
|
|
proc `[]`*(x: Node; idx: int): Element {.importcpp: "#.childNodes[#]".}
|
|
proc getElementById*(id: cstring): Element {.importc: "document.getElementById", nodecl.}
|
|
proc appendChild*(n, child: Node) {.importcpp.}
|
|
proc removeChild*(n, child: Node) {.importcpp.}
|
|
proc remove*(child: Node) {.importcpp.}
|
|
proc replaceChild*(n, newNode, oldNode: Node) {.importcpp.}
|
|
proc insertBefore*(n, newNode, before: Node) {.importcpp.}
|
|
proc getElementById*(d: Document, id: cstring): Element {.importcpp.}
|
|
proc createElement*(d: Document, identifier: cstring): Element {.importcpp.}
|
|
proc createElementNS*(d: Document, namespaceURI, qualifiedIdentifier: cstring): Element {.importcpp.}
|
|
proc createTextNode*(d: Document, identifier: cstring): Node {.importcpp.}
|
|
proc createComment*(d: Document, data: cstring): Node {.importcpp.}
|
|
|
|
proc setTimeout*(action: proc(); ms: int): TimeOut {.importc, nodecl.}
|
|
proc clearTimeout*(t: TimeOut) {.importc, nodecl.}
|
|
proc setInterval*(action: proc(); ms: int): Interval {.importc, nodecl.}
|
|
proc clearInterval*(i: Interval) {.importc, nodecl.}
|
|
|
|
{.push importcpp.}
|
|
|
|
# EventTarget "methods"
|
|
proc addEventListener*(et: EventTarget, ev: cstring, cb: proc(ev: Event), useCapture: bool = false)
|
|
proc addEventListener*(et: EventTarget, ev: cstring, cb: proc(ev: Event), options: AddEventListenerOptions)
|
|
proc dispatchEvent*(et: EventTarget, ev: Event)
|
|
proc removeEventListener*(et: EventTarget; ev: cstring; cb: proc(ev: Event))
|
|
|
|
# Window "methods"
|
|
proc alert*(w: Window, msg: cstring)
|
|
proc back*(w: Window)
|
|
proc blur*(w: Window)
|
|
proc clearInterval*(w: Window, interval: Interval)
|
|
proc clearTimeout*(w: Window, timeout: TimeOut)
|
|
proc close*(w: Window)
|
|
proc confirm*(w: Window, msg: cstring): bool
|
|
proc disableExternalCapture*(w: Window)
|
|
proc enableExternalCapture*(w: Window)
|
|
proc find*(w: Window, text: cstring, caseSensitive = false,
|
|
backwards = false): bool
|
|
proc focus*(w: Window)
|
|
proc forward*(w: Window)
|
|
proc getComputedStyle*(w: Window, e: Node, pe: Node = nil): Style
|
|
## .. warning:: The returned Style may or may not be read-only at run-time in the browser. getComputedStyle is performance costly.
|
|
|
|
proc handleEvent*(w: Window, e: Event)
|
|
proc home*(w: Window)
|
|
proc moveBy*(w: Window, x, y: int)
|
|
proc moveTo*(w: Window, x, y: int)
|
|
proc open*(w: Window, uri, windowname: cstring,
|
|
properties: cstring = nil): Window
|
|
proc print*(w: Window)
|
|
proc prompt*(w: Window, text, default: cstring): cstring
|
|
proc resizeBy*(w: Window, x, y: int)
|
|
proc resizeTo*(w: Window, x, y: int)
|
|
proc routeEvent*(w: Window, event: Event)
|
|
proc scrollBy*(w: Window, x, y: int)
|
|
proc scrollTo*(w: Window, x, y: int)
|
|
proc setInterval*(w: Window, code: cstring, pause: int): Interval
|
|
proc setInterval*(w: Window, function: proc (), pause: int): Interval
|
|
proc setTimeout*(w: Window, code: cstring, pause: int): TimeOut
|
|
proc setTimeout*(w: Window, function: proc (), pause: int): Interval
|
|
proc stop*(w: Window)
|
|
proc requestAnimationFrame*(w: Window, function: proc (time: float)): int
|
|
proc cancelAnimationFrame*(w: Window, id: int)
|
|
proc matchMedia*(w: Window, mediaQueryString: cstring): MediaQueryList
|
|
|
|
# Node "methods"
|
|
proc appendData*(n: Node, data: cstring)
|
|
proc cloneNode*(n: Node, copyContent: bool): Node
|
|
proc deleteData*(n: Node, start, len: int)
|
|
proc focus*(e: Node)
|
|
proc getAttribute*(n: Node, attr: cstring): cstring
|
|
proc getAttributeNode*(n: Node, attr: cstring): Node
|
|
proc hasAttribute*(n: Node, attr: cstring): bool
|
|
proc hasChildNodes*(n: Node): bool
|
|
proc normalize*(n: Node)
|
|
proc insertData*(n: Node, position: int, data: cstring)
|
|
proc removeAttribute*(n: Node, attr: cstring)
|
|
proc removeAttributeNode*(n, attr: Node)
|
|
proc replaceData*(n: Node, start, len: int, text: cstring)
|
|
proc scrollIntoView*(n: Node)
|
|
proc scrollIntoView*(n: Node, options: ScrollIntoViewOptions)
|
|
proc setAttribute*(n: Node, name, value: cstring)
|
|
proc setAttributeNode*(n: Node, attr: Node)
|
|
proc querySelector*(n: Node, selectors: cstring): Element
|
|
proc querySelectorAll*(n: Node, selectors: cstring): seq[Element]
|
|
proc compareDocumentPosition*(n: Node, otherNode:Node): int
|
|
proc lookupPrefix*(n: Node): cstring
|
|
proc lookupNamespaceURI*(n: Node): cstring
|
|
proc isDefaultNamespace*(n: Node): bool
|
|
proc contains*(n: Node): bool
|
|
proc isEqualNode*(n: Node): bool
|
|
proc isSameNode*(n: Node): bool
|
|
|
|
since (1, 3):
|
|
proc getRootNode*(n: Node,options: RootNodeOptions): Node
|
|
|
|
# DocumentOrShadowRoot
|
|
proc getSelection*(n: DocumentOrShadowRoot): Selection
|
|
proc elementFromPoint*(n: DocumentOrShadowRoot; x, y: float): Element
|
|
|
|
# shadow dom
|
|
proc attachShadow*(n: Element): ShadowRoot
|
|
proc assignedNodes*(n: HTMLSlotElement; options: SlotOptions): seq[Node]
|
|
proc assignedElements*(n: HTMLSlotElement; options: SlotOptions): seq[Element]
|
|
|
|
# Document "methods"
|
|
proc createAttribute*(d: Document, identifier: cstring): Node
|
|
proc getElementsByName*(d: Document, name: cstring): seq[Element]
|
|
proc getElementsByTagName*(d: Document, name: cstring): seq[Element]
|
|
proc getElementsByClassName*(d: Document, name: cstring): seq[Element]
|
|
proc insertNode*(range: Range, node: Node)
|
|
proc getSelection*(d: Document): Selection
|
|
proc handleEvent*(d: Document, event: Event)
|
|
proc open*(d: Document)
|
|
proc routeEvent*(d: Document, event: Event)
|
|
proc write*(d: Document, text: cstring)
|
|
proc writeln*(d: Document, text: cstring)
|
|
proc querySelector*(d: Document, selectors: cstring): Element
|
|
proc querySelectorAll*(d: Document, selectors: cstring): seq[Element]
|
|
|
|
# Element "methods"
|
|
proc blur*(e: Element)
|
|
proc click*(e: Element)
|
|
proc focus*(e: Element)
|
|
proc handleEvent*(e: Element, event: Event)
|
|
proc select*(e: Element)
|
|
proc getElementsByTagName*(e: Element, name: cstring): seq[Element]
|
|
proc getElementsByClassName*(e: Element, name: cstring): seq[Element]
|
|
|
|
# FormElement "methods"
|
|
proc reset*(f: FormElement)
|
|
proc submit*(f: FormElement)
|
|
proc checkValidity*(e: FormElement): bool
|
|
proc reportValidity*(e: FormElement): bool
|
|
|
|
# EmbedElement "methods"
|
|
proc play*(e: EmbedElement)
|
|
proc stop*(e: EmbedElement)
|
|
|
|
# Location "methods"
|
|
proc reload*(loc: Location)
|
|
proc replace*(loc: Location, s: cstring)
|
|
|
|
# History "methods"
|
|
proc back*(h: History)
|
|
proc forward*(h: History)
|
|
proc go*(h: History, pagesToJump: int)
|
|
proc pushState*[T](h: History, stateObject: T, title, url: cstring)
|
|
|
|
# Navigator "methods"
|
|
proc javaEnabled*(h: Navigator): bool
|
|
since (1, 3):
|
|
proc canShare*(self: Navigator; data: cstring): bool ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/canShare
|
|
proc sendBeacon*(self: Navigator; url, data: cstring): bool ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/sendBeacon
|
|
proc vibrate*(self: Navigator; pattern: cint): bool ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/vibrate
|
|
proc vibrate*(self: Navigator; pattern: openArray[cint]): bool ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/vibrate
|
|
proc registerProtocolHandler*(self: Navigator; scheme, url, title: cstring) ## https://developer.mozilla.org/en-US/docs/Web/API/Navigator/registerProtocolHandler
|
|
|
|
# ClassList "methods"
|
|
proc add*(c: ClassList, class: cstring)
|
|
proc remove*(c: ClassList, class: cstring)
|
|
proc contains*(c: ClassList, class: cstring): bool
|
|
proc toggle*(c: ClassList, class: cstring)
|
|
|
|
# Style "methods"
|
|
proc getPropertyValue*(s: Style, property: cstring): cstring
|
|
proc removeProperty*(s: Style, property: cstring)
|
|
proc setProperty*(s: Style, property, value: cstring, priority = "")
|
|
proc getPropertyPriority*(s: Style, property: cstring): cstring
|
|
|
|
# Event "methods"
|
|
proc preventDefault*(ev: Event)
|
|
proc stopImmediatePropagation*(ev: Event)
|
|
proc stopPropagation*(ev: Event)
|
|
|
|
# KeyboardEvent "methods"
|
|
proc getModifierState*(ev: KeyboardEvent, keyArg: cstring): bool
|
|
|
|
# MouseEvent "methods"
|
|
proc getModifierState*(ev: MouseEvent, keyArg: cstring): bool
|
|
|
|
# TouchEvent "methods"
|
|
proc identifiedTouch*(list: TouchList): Touch
|
|
proc item*(list: TouchList, i: int): Touch
|
|
|
|
# DataTransfer "methods"
|
|
proc clearData*(dt: DataTransfer, format: cstring)
|
|
proc getData*(dt: DataTransfer, format: cstring): cstring
|
|
proc setData*(dt: DataTransfer, format: cstring, data: cstring)
|
|
proc setDragImage*(dt: DataTransfer, img: Element, xOffset: int64, yOffset: int64)
|
|
|
|
# DataTransferItem "methods"
|
|
proc getAsFile*(dti: DataTransferItem): File
|
|
|
|
# InputElement "methods"
|
|
proc setSelectionRange*(e: InputElement, selectionStart: int, selectionEnd: int, selectionDirection: cstring = "none")
|
|
proc setRangeText*(e: InputElement, replacement: cstring, startindex: int = 0, endindex: int = 0, selectionMode: cstring = "preserve")
|
|
proc setCustomValidity*(e: InputElement, error: cstring)
|
|
proc checkValidity*(e: InputElement): bool
|
|
|
|
# Blob "methods"
|
|
proc slice*(e: Blob, startindex: int = 0, endindex: int = e.size, contentType: cstring = "")
|
|
|
|
# Performance "methods"
|
|
proc now*(p: Performance): float
|
|
|
|
# Selection "methods"
|
|
proc removeAllRanges*(s: Selection)
|
|
proc deleteFromDocument*(s: Selection)
|
|
proc getRangeAt*(s: Selection, index: int): Range
|
|
converter toString*(s: Selection): cstring
|
|
proc `$`*(s: Selection): string = $(s.toString())
|
|
|
|
# Storage "methods"
|
|
proc getItem*(s: Storage, key: cstring): cstring
|
|
proc setItem*(s: Storage, key, value: cstring)
|
|
proc clear*(s: Storage)
|
|
proc removeItem*(s: Storage, key: cstring)
|
|
|
|
{.pop.}
|
|
|
|
proc setAttr*(n: Node; key, val: cstring) {.importcpp: "#.setAttribute(@)".}
|
|
|
|
var
|
|
window* {.importc, nodecl.}: Window
|
|
navigator* {.importc, nodecl.}: Navigator
|
|
screen* {.importc, nodecl.}: Screen
|
|
|
|
when not defined(nodejs):
|
|
var document* {.importc, nodecl.}: Document
|
|
|
|
proc decodeURI*(uri: cstring): cstring {.importc, nodecl.}
|
|
proc encodeURI*(uri: cstring): cstring {.importc, nodecl.}
|
|
|
|
proc escape*(uri: cstring): cstring {.importc, nodecl.}
|
|
proc unescape*(uri: cstring): cstring {.importc, nodecl.}
|
|
|
|
proc decodeURIComponent*(uri: cstring): cstring {.importc, nodecl.}
|
|
proc encodeURIComponent*(uri: cstring): cstring {.importc, nodecl.}
|
|
proc isFinite*(x: BiggestFloat): bool {.importc, nodecl.}
|
|
proc isNaN*(x: BiggestFloat): bool {.importc, nodecl.}
|
|
## see also `math.isNaN`.
|
|
|
|
proc newEvent*(name: cstring): Event {.importcpp: "new Event(@)", constructor.}
|
|
|
|
proc getElementsByClass*(n: Node; name: cstring): seq[Node] {.
|
|
importcpp: "#.getElementsByClassName(#)", nodecl.}
|
|
|
|
|
|
type
|
|
BoundingRect* {.importc.} = object
|
|
top*, bottom*, left*, right*, x*, y*, width*, height*: float
|
|
|
|
proc getBoundingClientRect*(e: Node): BoundingRect {.
|
|
importcpp: "getBoundingClientRect", nodecl.}
|
|
proc clientHeight*(): int {.
|
|
importcpp: "(window.innerHeight || document.documentElement.clientHeight)@", nodecl.}
|
|
proc clientWidth*(): int {.
|
|
importcpp: "(window.innerWidth || document.documentElement.clientWidth)@", nodecl.}
|
|
|
|
proc inViewport*(el: Node): bool =
|
|
let rect = el.getBoundingClientRect()
|
|
result = rect.top >= 0 and rect.left >= 0 and
|
|
rect.bottom <= clientHeight().float and
|
|
rect.right <= clientWidth().float
|
|
|
|
proc scrollTop*(e: Node): int {.importcpp: "#.scrollTop", nodecl.}
|
|
proc `scrollTop=`*(e: Node, value: int) {.importcpp: "#.scrollTop = #", nodecl.}
|
|
proc scrollLeft*(e: Node): int {.importcpp: "#.scrollLeft", nodecl.}
|
|
proc scrollHeight*(e: Node): int {.importcpp: "#.scrollHeight", nodecl.}
|
|
proc scrollWidth*(e: Node): int {.importcpp: "#.scrollWidth", nodecl.}
|
|
proc offsetHeight*(e: Node): int {.importcpp: "#.offsetHeight", nodecl.}
|
|
proc offsetWidth*(e: Node): int {.importcpp: "#.offsetWidth", nodecl.}
|
|
proc offsetTop*(e: Node): int {.importcpp: "#.offsetTop", nodecl.}
|
|
proc offsetLeft*(e: Node): int {.importcpp: "#.offsetLeft", nodecl.}
|
|
|
|
since (1, 3):
|
|
func newDomParser*(): DomParser {.importcpp: "new DOMParser()".}
|
|
## DOM Parser constructor.
|
|
func parseFromString*(this: DomParser; str: cstring; mimeType: cstring): Document {.importcpp.}
|
|
## Parse from string to `Document`.
|
|
|
|
proc newDomException*(): DomException {.importcpp: "new DomException()", constructor.}
|
|
## DOM Exception constructor
|
|
proc message*(ex: DomException): cstring {.importcpp: "#.message", nodecl.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/DOMException/message
|
|
proc name*(ex: DomException): cstring {.importcpp: "#.name", nodecl.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/DOMException/name
|
|
|
|
proc newFileReader*(): FileReader {.importcpp: "new FileReader()", constructor.}
|
|
## File Reader constructor
|
|
proc error*(f: FileReader): DomException {.importcpp: "#.error", nodecl.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/error
|
|
proc readyState*(f: FileReader): FileReaderState {.importcpp: "#.readyState", nodecl.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readyState
|
|
proc resultAsString*(f: FileReader): cstring {.importcpp: "#.result", nodecl.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/result
|
|
proc abort*(f: FileReader) {.importcpp: "#.abort()".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/abort
|
|
proc readAsBinaryString*(f: FileReader, b: Blob) {.importcpp: "#.readAsBinaryString(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsBinaryString
|
|
proc readAsDataURL*(f: FileReader, b: Blob) {.importcpp: "#.readAsDataURL(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsDataURL
|
|
proc readAsText*(f: FileReader, b: Blob|File, encoding = cstring"UTF-8") {.importcpp: "#.readAsText(#, #)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsText
|
|
|
|
since (1, 5):
|
|
proc elementsFromPoint*(n: DocumentOrShadowRoot; x, y: float): seq[Element] {.importcpp.}
|
|
|
|
|
|
since (1, 7):
|
|
|
|
proc insertAdjacentText*(self: Node; position, data: cstring) {.importjs: "#.$1(#, #)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentText
|
|
|
|
proc insertAdjacentElement*(self: Node; position: cstring; element: Node) {.importjs: "#.$1(#, #)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentElement
|
|
|
|
proc insertAdjacentHTML*(self: Node; position, html: cstring) {.importjs: "#.$1(#, #)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentHTML
|
|
|
|
proc after*(self: Node; element: Node): Node {.importjs: "#.$1(@)", varargs.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/after
|
|
|
|
proc before*(self: Node; element: Node): Node {.importjs: "#.$1(@)", varargs.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/before
|
|
|
|
proc append*(self: Node; element: Node): Node {.importjs: "#.$1(@)", varargs.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/append
|
|
|
|
proc closest*(self: Node; cssSelector: cstring): Node {.importjs: "#.$1(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/closest
|
|
|
|
proc hasAttributeNS*(self: Node; namespace, localName: cstring): bool {.importjs: "(#.$1(#, #) || false)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/hasAttributeNS
|
|
|
|
proc removeAttributeNS*(self: Node; namespace, attributeName: cstring) {.importjs: "#.$1(#, #)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/removeAttributeNS
|
|
|
|
proc hasPointerCapture*(self: Node; pointerId: SomeNumber): bool {.importjs: "(#.$1(#) || false)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/hasPointerCapture
|
|
|
|
proc releasePointerCapture*(self: Node; pointerId: SomeNumber) {.importjs: "#.$1(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/releasePointerCapture
|
|
|
|
proc requestPointerLock*(self: Node) {.importjs: "#.$1()".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/requestPointerLock
|
|
|
|
proc replaceChildren*(self: Node; replacements: Node) {.importjs: "#.$1(@)", varargs.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/replaceChildren
|
|
|
|
proc replaceWith*(self: Node; replacements: Node) {.importjs: "#.$1(@)", varargs.}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/replaceWith
|
|
|
|
proc scrollIntoViewIfNeeded*(self: Node; centerIfNeeded: bool) {.importjs: "#.$1(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoViewIfNeeded
|
|
|
|
proc setHTML*(self: Node; html: cstring) {.importjs: "#.$1(#)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/setHTML
|
|
|
|
proc toggleAttribute*(self: Node; name: cstring; force = false): bool {.importjs: "(#.$1(#, #) || false)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/toggleAttribute
|
|
|
|
proc matches*(self: Node; cssSelector: cstring): bool {.importjs: "(#.$1(#) || false)".}
|
|
## https://developer.mozilla.org/en-US/docs/Web/API/Element/matches
|
|
|
|
|
|
since (2, 1):
|
|
type VisualViewport* {.importc.} = ref object of EventTarget
|
|
offsetLeft*, offsetTop*, pageLeft*, pageTop*, width*, height*, scale*: float
|
|
onResize*, onScroll*: proc (event: Event) {.closure.}
|
|
|
|
func visualViewport*(self: Window): VisualViewport {.importjs: "#.$1", nodecl.}
|