Scripting
is
an
optional
"convenience"
building
block
in
WoT
and
it
is
typically
used
in
gateways
that
are
able
to
run
a
WoT
Runtime
and
script
management
,
providing
a
convenient
way
to
extend
WoT
support
to
new
types
of
endpoints
and
implement
WoT
applications
like
Thing
Directory
.
Status
of
This
Document
This
section
describes
the
status
of
this
document
at
the
time
of
its
publication.
Other
documents
may
supersede
this
document.
A
list
of
current
W3C
publications
and
the
latest
revision
of
this
technical
report
can
be
found
in
the
W3C
technical
reports
index
at
https://www.w3.org/TR/.
Implementers
need
to
be
aware
that
this
specification
is
considered
unstable.
Vendors
interested
in
implementing
this
specification
before
it
eventually
reaches
the
Candidate
Recommendation
phase
should
subscribe
to
the
repository
and
take
part
in
the
discussions.
Editor's
note
:
The
W3C
WoT
WG
is
asking
for
feedback
Changes
from
the
previous
publication
can
be
found
in
Appendix
A
.
A
diff-marked
version
of
this
document
is
also
available
for
comparison
purposes.
Publication
as
a
First
Public
Working
Draft
does
not
imply
endorsement
by
the
W3C
Membership.
This
is
a
draft
document
and
may
be
updated,
replaced
or
obsoleted
by
other
documents
at
any
time.
It
is
inappropriate
to
cite
this
document
as
other
than
work
in
progress.
This
document
was
produced
by
a
group
operating
under
the
5
February
2004
W3C
Patent
Policy
.
W3C
maintains
a
public
list
of
any
patent
disclosures
made
in
connection
with
the
deliverables
of
the
group;
that
page
also
includes
instructions
for
disclosing
a
patent.
An
individual
who
has
actual
knowledge
of
a
patent
which
the
individual
believes
contains
Essential
Claim(s)
must
disclose
the
information
in
accordance
with
section
6
of
the
W3C
Patent
Policy
.
The
overall
WoT
concepts
are
described
in
the
WoT
Architecture
document.
The
Web
of
Things
is
made
of
entities
(
Thing
s)
that
can
describe
their
capabilities
in
a
machine-interpretable
format,
the
Thing
Description
(TD)
and
expose
these
capabilities
through
the
WoT
Interface
.
Support
for
scripting
is
optional
for
WoT
devices.
Exposing
a
Thing
requires
defining
a
Thing
Description
(TD)
and
instantiating
a
software
stack
needed
to
serve
requests
for
accessing
the
exposed
properties,
Properties
,
Actions
and
Events
.
This
specification
describes
how
to
expose
and
consume
Thing
s
by
a
script.
Note
Typically
scripts
are
meant
to
be
used
on
devices
able
to
provide
resources
(with
a
WoT
interface
)
for
managing
(installing,
updating,
running)
scripts,
such
as
bridges
or
gateways
that
expose
and
control
simpler
devices
as
WoT
Thing
s.
Note
This
specification
does
not
make
assumptions
on
how
the
WoT
Runtime
handles
and
runs
scripts,
including
single
or
multiple
tenancy,
script
deployment
and
lifecycle
management.
The
API
already
supports
the
generic
mechanisms
that
make
it
possible
to
implement
script
management,
for
instance
by
exposing
a
manager
Thing
whose
Actions
(action
handlers)
implement
script
lifecycle
management
operations.
For
an
introduction
on
how
scripts
could
be
used
in
Web
of
Things
,
check
the
Primer
document.
For
some
background
on
API
design
decisions
check
the
Rationale
document.
2.
Use
Cases
This
section
is
non-normative.
The
following
scripting
use
cases
are
covered
supported
in
this
specification:
2.1
Discovery
Discover
all
Thing
s
in
the
WoT
network
by
sending
a
broadcast
request.
Emit
an
Event
,
i.e.
notify
all
listeners
subscribed
to
that
Event
.
Register
handlers
Provide
notifications
for
external
requests:
to
retrieve
a
Property
value;
to
update
a
Property
TD
value;
to
run
an
Action
:
take
the
parameters
from
the
request,
execute
the
defined
action,
and
return
the
result;
to
add
a
listener
changes
to
an
Event
;
clients
subscribed
to
remove
an
Event
listener.
that.
to
fetch
Mark/unmark
the
Thing
Description
;
Register
the
Thing.
to
be
discoverable.
Unregister
Mark/unmark
the
Thing.
Thing
to
be
consumable.
Start
the
exposed
Thing
in
order
to
process
external
requests.
Register
handlers
for
next
versions:
external
requests:
Add,
remove
and
update
the
definition
of
to
retrieve
a
Property
on
a
Thing
that
runs
in
the
same
the
WoT
Runtime.
value;
Add,
remove
and
to
update
the
definition
of
an
Action
on
a
Thing
that
runs
in
the
same
the
WoT
Runtime.
Property
value;
Add,
remove
and
update
the
definition
of
to
run
an
Event
on
a
Thing
that
runs
in
Action
:
take
the
same
parameters
from
the
WoT
Runtime.
request,
execute
the
defined
action,
and
return
the
result;
3.
The
WoT
object
The
WoT
object
is
the
main
API
entry
point
and
it
is
exposed
by
an
implementation
of
the
WoT
Runtime
.
The
WoT
object
has
no
internal
state
and
provides
does
not
expose
properties,
only
methods
for
discovering,
consuming
and
exposing
a
Thing
.
Note
Browser
implementations
SHOULD
use
a
namespace
object
such
as
wot
,
and
Node.js
-like
runtimes
MAY
provide
the
API
object
through
the
require()
or
import
mechanism.
The
algorithms
for
the
WoT
methods
will
be
specified
later.
later,
including
error
handling
and
security
considerations.
3.1
The
discover()
method
Starts
the
discovery
process
that
will
provide
ConsumedThing
objects
that
match
the
optional
argument
ThingFilter
.
.
When
the
argument
is
not
provided,
starts
the
widest
discovery
the
Thing
Description
and
Protocol
Bindings
allow.
allow
and
support.
Returns
an
Observable
object
that
can
be
subscribed
to
and
unsubscribed
to.
from.
The
method
property
represents
the
discovery
type
that
should
be
used
in
the
discovery
process.
The
possible
values
are
defined
by
the
DiscoveryMethod
enumeration
that
can
be
extended
by
string
values
defined
by
solutions
(with
no
guarantee
of
interoperability).
The
url
property
represents
additional
information
for
the
discovery
method,
such
as
the
URL
of
the
Thing
Directory
server
to
be
used.
The
description
property
represents
additional
information
for
the
discovery
method
in
the
form
of
a
set
of
key-value
pairs,
as
defined
in
the
Thing
Description
.
Editor's
note
The
DiscoveryMethod
enumeration
can
be
extended
by
the
Thing
Description
with
values
that
are
not
specified
here.
This
extensibility
of
DiscoveryMethod
by
proprietary
or
private
methods
is
a
working
assumption
until
consensus
is
formed
and
may
be
removed
later.
Editor's
note
The
ThingFilter
url
property
represents
additional
information
for
the
discovery
method,
such
as
the
URL
of
the
target
entity
serving
the
discovery
request,
such
as
a
Thing
Directory
dictionary
may
be
extended
later
with
further
attributes.
or
a
Thing.
3.1.2
The
DiscoveryMethod
query
enumeration
<span class="idlEnum" id=
"idl-def-discoverymethod" data-idl="" data-title=
"DiscoveryMethod">enum <a data-lt=
"DiscoveryMethod" href="#dom-discoverymethod" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<a href="#dom-discoverymethod-any" class=
"idlEnumItem">"any",
<a href="#dom-discoverymethod-local" class=
"idlEnumItem">"local",
<a href="#dom-discoverymethod-nearby" class=
"idlEnumItem">"nearby",
<a href="#dom-discoverymethod-directory" class=
"idlEnumItem">"directory",
<a href="#dom-discoverymethod-broadcast" class=
"idlEnumItem">"broadcast",
<a href="#dom-discoverymethod-other" class=
"idlEnumItem">"other"
};
property
represents
a
query
string
accepted
by
the
implementation,
for
instance
a
SPARQL
query.
The
DiscoveryMethod
constraints
enumeration
property
represents
additional
information
for
the
discovery
type
method
in
the
form
of
a
list
of
sets
of
property-value
pairs
(dictionaries).
The
list
elements
(dictionaries)
are
in
OR
relationship,
and
within
a
constraint
dictionary
the
key-value
pairs
are
in
AND
relationship.
Implementations
SHOULD
make
the
following
mapping
from
the
constraint
dictionaries
to
be
used:
"
any
SemanticAnnotations
"
does
not
provide
any
restriction
:
for
each
property-value
pair
in
a
constraint
dictionary,
"
Each
property
name
in
the
constraint
dictionary
SHOULD
match
the
either
the
local
name
"
for
discovering
Thing
s
property
of
a
defined
in
the
same
device
"
nearby
SemanticType
"
for
discovering
Thing
s
nearby
on
the
device,
e.g.
by
Bluetooth
target
Thing
object,
or
NFC
the
name
of
a
Property
on
the
target
Thing
.
"
When
the
name
matches,
the
values
are
compared.
If
the
values
match,
the
constraint
is
matched.
Editor's
note
Constraints
are
experimental
feature,
implementations
are
not
required
to
support
them.
Editor's
note
Semantic
annotations
need
revisiting
in
order
to
simplify
their
representation.
In
the
[
WOT-TD
]
specification
they
represent
the
directory
@type
construct.
At
the
moment
only
@context
,
@type
and
@id
constructs
are
used
in
the
TD
.
"
for
discovery
based
on
a
service
provided
by
a
directory
or
repository
of
Thing
s
"
3.2
The
broadcast
fetch()
"
for
method
Accepts
an
open
ended
discovery
based
on
sending
url
argument
and
returns
a
request
to
Promise
that
resolves
with
a
broadcast
address
"
other
ThingDescription
.
3.3
The
ThingDescription
"
for
a
proprietary
method
defined
by
type
In
this
version
of
the
API,
Thing
Description
s
are
represented
as
opaque
strings,
denoting
a
serialized
form,
for
instance
JSON
or
JSON-LD.
See
Issue
38
and
Issue
45
.
3.2
3.4
The
consume()
method
Accepts
an
url
td
argument
and
returns
a
of
type
Promise
ThingDescription
of
and
returns
a
ConsumedThing
.
object
instantiated
based
on
that
description.
3.3
3.5
The
expose()
produce()
method
Returns
Accepts
a
model
argument
of
type
ThingModel
Promise
of
a
locally
created
and
returns
an
ExposedThing
object,
locally
created
based
on
the
provided
initialization
parameters.
Editor's
note
The
reason
An
ExposedThing
s
are
can
be
created
by
in
the
following
ways:
from
an
initial
model
(including
a
factory
method
instead
user
given
name
and
semantic
annotations
),
then
adding
properties,
actions,
events
and
request
handlers;
A
Thing
model
is
that
an
used
for
producing
a
new
ExposedThing
may
and
can
be
created
in
the
local
WoT
Runtime
either
a
ThingTemplate
,
or
in
a
remote
runtime.
Even
though
currently
only
local
creation
is
supported,
the
method
is
designed
with
this
possible
future
compatibility
in
mind.
ThingDescription
.
3.3.1
3.7
The
ThingInit
SemanticAnnotations
dictionary
A
dictionary
that
provides
the
semantic
types
and
semantic
metadata.
The
ThingInit
semanticType
property
denotes
a
list
of
SemanticType
objects
that
define
the
semantic
types
that
can
be
used
in
semantic
metadata
type-value
pairs.
The
metadata
property
denotes
a
list
of
SemanticMetadata
objects
(type-value
pairs).
3.8
The
SemanticType
dictionary
contains
properties
to
initialize
The
SemanticMetadata
dictionary
describes
a
pair
of
semantic
type
and
value:
The
type
attribute
represents
the
semantic
type
name
defined
by
a
SemanticType
object.
The
value
attribute
represents
the
metadata
value.
3.10
The
ThingTemplate
dictionary
A
Thing
Template
is
a
dictionary
that
provides
a
user
given
name,
and
the
semantic
types
and
semantic
metadata
attached
to
the
ExposedThing
Thing
Description
's
root
level.
Note
that
canceling
a
discovery
(through
unsubscribe)
unsubscribe()
)
may
not
be
successful
in
all
cases,
for
instance
when
discovery
is
based
on
open
ended
broadcast
requests.
However,
once
unsubscribe()
has
been
called,
implementations
MUST
suppress
further
event
handling
(
i.e.
further
discoveries
and
errors)
on
the
Observable.
Also,
a
discovery
error
may
not
mean
the
end
of
the
discovery
process.
However,
in
order
to
respect
Observable
semantics
(error
always
terminates
processing),
implementations
MUST
close
or
suppress
further
event
handling
on
the
Observable.
Example
2
:
Discover
Things
exposed
by
local
hardware
Takes
the
Action
Property
name
from
as
the
name
argument
and
the
list
of
parameters,
argument,
then
requests
from
the
underlying
platform
and
the
Protocol
Bindings
to
invoke
retrieve
the
Action
Property
on
the
remote
Thing
and
return
the
result.
Returns
a
Promise
that
resolves
with
the
return
Property
value
or
rejects
with
an
Error
.
4.2
4.4
The
setProperty()
writeProperty()
method
Takes
the
Property
name
as
the
name
argument
and
the
new
value
as
the
value
argument,
then
requests
from
the
underlying
platform
and
the
Protocol
Bindings
to
update
the
Property
on
the
remote
Thing
and
return
the
result.
Returns
a
Promise
that
resolves
on
success
or
rejects
with
an
Error
.
4.3
4.5
The
getProperty()
invokeAction()
method
Takes
the
Property
Action
name
as
from
the
name
argument,
argument
and
the
list
of
parameters,
then
requests
from
the
underlying
platform
and
the
Protocol
Bindings
to
retrieve
invoke
the
Property
Action
on
the
remote
Thing
and
return
the
result.
Returns
a
Promise
that
resolves
with
the
Property
return
value
or
rejects
with
an
Error
.
4.4
4.6
The
addListener()
onPropertyChange()
method
Adds
the
listener
provided
in
the
argument
listener
to
the
Event
name
provided
in
the
argument
eventName
.
4.5
The
Returns
an
removeListener()
Observable
method
Removes
a
listener
from
for
the
Event
Property
identified
by
specified
in
the
provided
eventName
name
argument,
allowing
subscribing
to
and
listener
argument.
unsubscribing
from
notifications.
4.6
The
callback
function
passed
to
the
removeAllListeners()
subscribe()
method
Removes
all
listeners
for
when
invoked
on
the
Event
provided
by
returned
observer
will
receive
the
eventName
optional
argument,
or
if
that
was
not
provided,
then
removes
all
listeners
from
all
Events
.
new
property
value
each
time
it
is
changed.
4.7
The
observe()
onEvent()
method
Returns
an
Observable
for
the
Property
,
Event
or
Action
specified
in
the
name
argument,
allowing
subscribing
to
and
unsubscribing
to
from
notifications.
The
requestType
specifies
whether
a
Property
,
an
Event
or
an
Action
is
observed.
Editor's
note
The
observe()
method
could
replace
addListener()
and
removeListener()
,
though
they
could
be
kept
for
convenience.
4.8
The
ThingEventListener
callback
A
function
called
with
an
Event
object
when
an
event
is
emitted.
4.9
Events
Clients
can
subscribe
passed
to
the
Events
defined
in
ExposedThing
events
.
The
event
types
are
described
in
this
section.
4.9.1
The
PropertyChangeEvent
interface
<span class="idlInterface" id=
"idl-def-propertychangeevent" data-idl="" data-title=
"PropertyChangeEvent">[<span class=
"extAttrName"><a href=
"https://heycam.github.io/webidl/#Constructor">Constructor<a href="#dom-propertychangeeventinit"
class="internalDFN" data-link-type=
"dfn"> <span class=
"idlParamName">init]
interface <a data-lt=
"PropertyChangeEvent" href="#dom-propertychangeevent" class=
"internalDFN" data-link-type="dfn" data-for=
""> : <span class=
"idlSuperclass"><a href="#dfn-event" class="internalDFN"
data-link-type="dfn">Event {
<span class="idlAttribute" id="idl-def-propertychangeevent-data"
data-idl="" data-title="data" data-dfn-for=
"propertychangeevent"> readonly attribute <span class=
"idlAttrType"><a href="#dom-propertychangeeventinit" class=
"internalDFN" data-link-type=
"dfn"> <span class=
"idlAttrName"><a data-lt="data" href=
"#dom-propertychangeevent-data" class="internalDFN" data-link-type=
"dfn" data-for=
"PropertyChangeEvent">
};
The
data
attribute
represents
the
changed
Property
.
4.9.1.1
The
PropertyChangeEventInit
dictionary
<span class="idlDictionary" id=
"idl-def-propertychangeeventinit" data-idl="" data-title=
"PropertyChangeEventInit">dictionary <span class=
"idlDictionaryID"><a data-lt="PropertyChangeEventInit" href=
"#dom-propertychangeeventinit" class="internalDFN" data-link-type=
"dfn" data-for=""> {
<span class="idlMember" id="idl-def-propertychangeeventinit-name"
data-idl="" data-title="name" data-dfn-for=
"propertychangeeventinit"> <a href=
"https://heycam.github.io/webidl/#idl-DOMString">DOMString<a data-lt="name"
href="#dom-propertychangeeventinit-name" class="internalDFN"
data-link-type="dfn" data-for=
"PropertyChangeEventInit">
<span class="idlMember" id="idl-def-propertychangeeventinit-value"
data-idl="" data-title="value" data-dfn-for=
"propertychangeeventinit"> <a href=
"https://heycam.github.io/webidl/#idl-any">any<a data-lt="value"
href="#dom-propertychangeeventinit-value" class="internalDFN"
data-link-type="dfn" data-for=
"PropertyChangeEventInit">
};
The
name
>
attribute
represents
the
Property
name.
The
value
subscribe()
attribute
represents
the
new
value
of
method
when
invoked
on
the
Property
.
4.9.2
The
ActionInvocationEvent
interface
<span class="idlInterface" id=
"idl-def-actioninvocationevent" data-idl="" data-title=
"ActionInvocationEvent">[<span class=
"extAttrName"><a href=
"https://heycam.github.io/webidl/#Constructor">Constructor<a href="#dom-actioninvocationeventinit"
class="internalDFN" data-link-type=
"dfn">]
interface <a data-lt=
"ActionInvocationEvent" href="#dom-actioninvocationevent" class=
"internalDFN" data-link-type="dfn" data-for=
""> : <span class=
"idlSuperclass"><a href="#dfn-event" class="internalDFN"
data-link-type="dfn">Event {
<span class="idlAttribute" id="idl-def-actioninvocationevent-data"
data-idl="" data-title="data" data-dfn-for=
"actioninvocationevent"> readonly attribute <span class=
"idlAttrType"><a href="#dom-actioninvocationeventinit" class=
"internalDFN" data-link-type=
"dfn"><a data-lt="data"
href="#dom-actioninvocationevent-data" class="internalDFN"
data-link-type="dfn" data-for=
"ActionInvocationEvent">
};
The
data
attribute
represents
returned
observer
will
receive
the
notification
event
data
from
the
Action
invocation.
4.9.2.1
The
ActionInvocationEventInit
dictionary
<span class="idlDictionary" id=
"idl-def-actioninvocationeventinit" data-idl="" data-title=
"ActionInvocationEventInit">dictionary <span class=
"idlDictionaryID"><a data-lt="ActionInvocationEventInit" href=
"#dom-actioninvocationeventinit" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<span class="idlMember" id=
"idl-def-actioninvocationeventinit-actionname" data-idl=""
data-title="actionName" data-dfn-for=
"actioninvocationeventinit"> <span class=
"idlMemberType"><a data-lt="actionName"
href="#dom-actioninvocationeventinit-actionname" class=
"internalDFN" data-link-type="dfn" data-for=
"ActionInvocationEventInit">
<span class="idlMember" id=
"idl-def-actioninvocationeventinit-returnvalue" data-idl=""
data-title="returnValue" data-dfn-for=
"actioninvocationeventinit"> <span class=
"idlMemberType"><a data-lt="returnValue"
href="#dom-actioninvocationeventinit-returnvalue" class=
"internalDFN" data-link-type="dfn" data-for=
"ActionInvocationEventInit">
};
Editor's
note
Action
parameters
could
be
also
included,
but
it's
debatable
because
privacy
reasons.
The
actionName
attribute
represents
the
name
of
the
Action
that
has
been
invoked.
The
returnValue
attribute
represents
the
return
value
of
each
time
the
Action
.
event
is
fired.
4.9.3.1
The
ThingDescriptionChangeEventInit
dictionary
<span class="idlDictionary" id=
"idl-def-thingdescriptionchangeeventinit" data-idl="" data-title=
"ThingDescriptionChangeEventInit">dictionary <span class=
"idlDictionaryID"><a data-lt="ThingDescriptionChangeEventInit"
href="#dom-thingdescriptionchangeeventinit" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<span class="idlMember" id=
"idl-def-thingdescriptionchangeeventinit-type" data-idl=""
data-title="type" data-dfn-for=
"thingdescriptionchangeeventinit"> <span class=
"idlMemberType"><a href="#dom-tdchangetype" class="internalDFN"
data-link-type=
"dfn"> <span class=
"idlMemberName"><a data-lt="type" href=
"#dom-thingdescriptionchangeeventinit-type" class="internalDFN"
data-link-type="dfn" data-for=
"ThingDescriptionChangeEventInit">
<span class="idlMember" id=
"idl-def-thingdescriptionchangeeventinit-method" data-idl=""
data-title="method" data-dfn-for=
"thingdescriptionchangeeventinit"> <span class=
"idlMemberType"><a href="#dom-tdchangemethod" class="internalDFN"
data-link-type=
"dfn"> <span class=
"idlMemberName"><a data-lt="method" href=
"#dom-thingdescriptionchangeeventinit-method" class="internalDFN"
data-link-type="dfn" data-for=
"ThingDescriptionChangeEventInit">
<span class="idlMember" id=
"idl-def-thingdescriptionchangeeventinit-name" data-idl=""
data-title="name" data-dfn-for=
"thingdescriptionchangeeventinit"> <span class=
"idlMemberType"><a href=
"https://heycam.github.io/webidl/#idl-DOMString">DOMString<a data-lt="name"
href="#dom-thingdescriptionchangeeventinit-name" class=
"internalDFN" data-link-type="dfn" data-for=
"ThingDescriptionChangeEventInit">
<span class="idlMember" id=
"idl-def-thingdescriptionchangeeventinit-data" data-idl=""
data-title="data" data-dfn-for=
"thingdescriptionchangeeventinit"> <span class=
"idlMemberType"><a href="#dom-tdchangedata" class="internalDFN"
data-link-type=
"dfn"> <span class=
"idlMemberName"><a data-lt="data" href=
"#dom-thingdescriptionchangeeventinit-data" class="internalDFN"
data-link-type="dfn" data-for=
"ThingDescriptionChangeEventInit">
<span class="idlMember" id=
"idl-def-thingdescriptionchangeeventinit-description" data-idl=""
data-title="description" data-dfn-for=
"thingdescriptionchangeeventinit"> <span class=
"idlMemberType"><a href="#dom-thingdescription" class="internalDFN"
data-link-type=
"dfn"> <span class=
"idlMemberName"><a data-lt="description" href=
"#dom-thingdescriptionchangeeventinit-description" class=
"internalDFN" data-link-type="dfn" data-for=
"ThingDescriptionChangeEventInit">
};
The
type
attribute
represents
the
change
type,
whether
has
it
been
applied
on
properties,
Actions
or
Events
.
The
method
attribute
tells
what
operation
has
been
applied,
addition,
removal
or
change.
The
name
attribute
represents
the
name
of
the
Property
,
Action
or
event
that
has
changed.
The
description
attribute
is
defined
for
the
addition
and
change
methods,
and
represents
the
new
description.
The
data
attribute
provides
the
initialization
data
for
the
added
or
changed
elements.
4.9.3.1.1
The
TDChangeMethod
enumeration
<span class="idlEnum" id=
"idl-def-tdchangemethod" data-idl="" data-title=
"TDChangeMethod">enum <a data-lt=
"TDChangeMethod" href="#dom-tdchangemethod" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<a href="#dom-tdchangemethod-add" class=
"idlEnumItem">"add",
<a href="#dom-tdchangemethod-remove" class=
"idlEnumItem">"remove",
<a href="#dom-tdchangemethod-change" class=
"idlEnumItem">"change"
};
The
add
value
denotes
addition
of
a
Property
,
Action
or
event.
The
remove
value
denotes
removal
of
a
Property
,
Action
or
event.
The
change
value
denotes
a
change
applied
on
a
Property
,
Action
or
event.
4.9.3.1.2
The
TDChangeType
enumeration
<span class="idlEnum" id=
"idl-def-tdchangetype" data-idl="" data-title=
"TDChangeType">enum <a data-lt=
"TDChangeType" href="#dom-tdchangetype" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<a href="#dom-tdchangetype-property" class=
"idlEnumItem">"property",
<a href="#dom-tdchangetype-action" class=
"idlEnumItem">"action",
<a href="#dom-tdchangetype-event" class=
"idlEnumItem">"event"
};
<span class="idlTypedef" id="idl-def-tdchangedata" data-idl=""
data-title="TDChangeData">typedef <span class=
"idlTypedefType">(<a href="#dom-thingpropertyinit" class=
"internalDFN" data-link-type=
"dfn"> or <a href=
"#dom-thingactioninit" class="internalDFN" data-link-type=
"dfn"> or <a href=
"#dom-thingeventinit" class="internalDFN" data-link-type=
"dfn"> <span class=
"idlTypedefID"><a data-lt="TDChangeData" href="#dom-tdchangedata"
class="internalDFN" data-link-type="dfn" data-for=
"">
TDChangeData
;
The
property
value
tells
callback
function
passed
to
the
operation
was
applied
on
a
Property
definition.
The
action
subscribe()
value
tells
the
operation
was
applied
method
when
invoked
on
a
action
definition.
The
event
value
tells
the
operation
was
applied
on
an
event
definition.
4.9.3.1.3
The
TDChangeData
type
Represents
returned
observer
will
receive
the
new
description
of
the
changed
element.
Depending
on
the
change
type,
Thing
Description
each
time
it
can
be
either
a
ThingPropertyInit
,
ThingActionInit
,
or
ThingEventInit
.
is
changed.
Represents
an
incoming
request
Stop
serving
external
requests
for
the
Thing
.
5.3
The
ExposedThing
register()
method
Generates
the
Thing
Description
is
supposed
to
handle,
for
instance
retrieving
and
updating
given
the
properties,
invoking
Actions
and
observing
Events
Event
(WoT
interactions).
The
type
attribute
represents
the
type
of
the
request
as
defined
in
RequestType
.
The
for
this
object.
If
a
from
directory
attribute
represents
the
address
of
the
client
device
issuing
the
request.
The
type
of
the
address
(URL,
UUID
or
other)
argument
is
defined
by
given,
make
a
request
to
register
the
Thing
Description
.
The
name
attribute
represents
the
name
of
the
Property
to
be
retrieved
or
updated,
or
the
name
of
the
invoked
Action
,
or
the
event
name
to
be
observed.
The
options
attribute
represents
the
options
relevant
to
the
request
(e.g.
the
format
or
measurement
units
for
with
the
returned
value)
as
key-value
pairs.
The
exact
format
is
specified
given
WoT
repository
by
the
Thing
Description
.
The
invoking
its
data
register
attribute
represents
the
value
of
the
Property
,
or
the
input
data
(arguments)
of
an
Action
.
It
is
not
used
for
retrieve
requests
and
event
requests,
only
for
Property
update
and
Action
invocation
requests.
5.2.1
The
RequestType
If
a
Property
.
The
value
"
action
"
represents
requests
to
invoke
an
Action
.
The
value
"
event
"
represents
requests
to
emit
an
event.
The
value
"
td
directory
"
represents
requests
argument
is
given,
make
a
request
to
change
unregister
the
Thing
Description
,
i.e.
to
add,
remove
or
modify
properties,
Actions
or
Events
.
Editor's
note
This
functionality
is
here
for
with
the
sake
of
completeness
for
future
versions
of
given
WoT
repository
by
invoking
its
unregister
Action
.
Then,
and
in
the
API.
Currently
there
is
case
no
corresponding
functionality
at
arguments
were
provided
to
this
function,
stop
the
ConsumedThing
Thing
level
and
it
is
not
guaranteed
that
a
remove
the
Thing
Description
could
be
remotely
changed
by
scripting.
.
5.2.2
5.5
The
respond()
emitEvent()
method
Sends
a
positive
response
to
Emits
an
the
event
initialized
with
the
event
name
specified
by
the
Request
eventName
based
on
the
Protocol
Bindings
argument
and
includes
the
data
specified
by
the
data
payload
argument.
5.2.3
5.6
The
respondWithError()
DataSchema
method
Sends
a
negative
response
to
the
type
"idl-def-dataschema" data-idl="" data-title=
"DataSchema">typedef USVStringRequest
DataSchema
based
on
the
Protocol
Bindings
and
includes
the
error
specified
by
the
error
argument.
5.3
;
Request
DataSchema
and
should
return
an
object
or
value
that
is
used
by
Protocol
Bindings
to
reply
to
the
request.
The
returned
under
development,
currently
it
can
denote
any
type
is
defined
supported
by
the
Thing
Description
and
the
WoT
Runtime
.
5.4
5.7
The
addProperty()
method
Adds
a
Property
defined
by
the
argument
and
updates
the
Thing
Description
.
Throws
on
error.
Returns
a
reference
to
the
same
object
for
supporting
chaining.
5.4.1
5.7.1
The
ThingPropertyInit
ThingProperty
dictionary
The
name
attribute
represents
the
name
of
the
Property
.
The
value
schema
attribute
represents
the
value
of
data
type
for
the
Property
described
by
DataSchema
.
The
configurable
value
attribute
defines
whether
the
Property
can
be
deleted
from
represents
the
object
and
whether
its
properties
can
be
changed.
The
default
value
is
false
.
of
the
Property
.
The
enumerable
writable
attribute
defines
whether
the
Property
can
be
listed
and
iterated.
updated.
The
default
value
is
true
false
.
The
writable
observable
attribute
defines
whether
the
Property
changes
can
be
updated.
observed
by
an
external
client.
The
default
value
is
true
false
.
The
semanticTypes
attribute
represents
a
list
of
semantic
type
annotations
(e.g.
labels,
classifications
etc)
relevant
to
the
Property
,
represented
as
SemanticType
dictionaries.
The
description
attribute
represents
the
Property
description
to
be
added
to
the
Thing
Description
.
5.4.2
The
SemanticType
dictionary
<span class="idlDictionary" id=
"idl-def-semantictype" data-idl="" data-title=
"SemanticType">dictionary <a data-lt=
"SemanticType" href="#dom-semantictype" class="internalDFN"
data-link-type="dfn" data-for=
""> {
<span class="idlMember" id="idl-def-semantictype-name" data-idl=""
data-title="name" data-dfn-for="semantictype"> <span class=
"idlMemberType"><a href=
"https://heycam.github.io/webidl/#idl-DOMString">DOMString<a data-lt="name"
href="#dom-semantictype-name" class="internalDFN" data-link-type=
"dfn" data-for="SemanticType">
<span class="idlMember" id="idl-def-semantictype-context" data-idl=
"" data-title="context" data-dfn-for=
"semantictype"> <a href=
"https://heycam.github.io/webidl/#idl-USVString">USVString<a data-lt="context"
href="#dom-semantictype-context" class="internalDFN"
data-link-type="dfn" data-for=
"SemanticType">
};
Represents
a
semantic
type
annotation,
containing
a
name
and
a
context.
The
name
attribute
represents
the
name
of
the
semantic
type
in
the
given
context.
The
context
attribute
represents
an
URL
link
to
the
context
of
the
semantic
classification.
Editor's
note
Semantic
type
examples
to
be
added.
5.5
5.8
The
removeProperty()
method
Removes
the
Property
specified
by
the
name
argument,
argument
and
updates
the
Thing
Description
and
returns
.
Throws
on
error.
Returns
a
reference
to
the
object.
same
object
for
supporting
chaining.
The
action
attribute
provides
a
function
that
defines
the
Action
.
The
inputDataDescription
inputSchema
attribute
provides
the
description
of
the
input
arguments
(argument
list
is
represented
by
an
object).
If
missing,
it
means
the
action
does
not
accept
arguments.
The
outputDataDescription
outputSchema
attribute
provides
the
description
of
the
returned
data.
The
semanticTypes
attribute
provides
a
list
of
semantic
type
annotations
(e.g.
labels,
classifications
etc)
relevant
to
If
missing,
it
means
the
Action
,
represented
as
SemanticType
dictionaries.
action
does
not
return
data.
5.7
5.10
The
removeAction()
method
Removes
the
Action
specified
by
the
name
argument,
argument
and
updates
the
Thing
Description
and
returns
.
Throws
on
error.
Returns
a
reference
to
the
object.
same
object
for
supporting
chaining.
5.8
5.11
The
addEvent()
method
Adds
an
event
to
the
Thing
object
as
defined
by
the
event
argument
of
type
ThingEventInit
ThingEvent
and
updates
the
Thing
Description
.
Throws
on
error.
Returns
a
reference
to
the
same
object
for
supporting
chaining.
5.8.1
5.11.1
The
ThingEventInit
ThingEvent
dictionary
The
semanticTypes
attribute
represent
a
list
of
semantic
type
annotations
attached
to
the
event.
The
dataDescription
schema
attribute
represents
the
description
type
of
the
data
that
is
attached
to
the
event.
If
missing,
it
means
the
event
does
not
carry
data.
5.9
5.12
The
removeEvent()
method
Removes
the
event
specified
by
the
name
argument,
argument
and
updates
the
Thing
Description
and
returns
.
Returns
a
reference
to
the
object.
same
object
for
supporting
chaining.
5.10
5.13
The
onRetrieveProperty()
PropertyReadHandler
method
callback
Registers
the
handler
A
function
for
that
returns
a
Promise
and
resolves
it
with
the
value
of
the
Property
retrieve
requests
received
for
matching
the
Thing
,
as
defined
by
name
argument
to
the
handler
setPropertyReadHandler
function,
or
rejects
with
an
error
if
the
property
of
type
is
not
found
or
the
value
cannot
be
retrieved.
5.14
The
RequestHandler
PropertyWriteHandler
callback
A
function
called
with
value
.
The
handler
will
receive
an
as
argument
request
that
returns
a
Promise
which
is
resolved
when
the
value
of
type
the
Property
matching
the
name
argument
to
the
Request
setPropertyReadHandler
function
is
updated
with
value
,
or
rejects
with
an
error
if
the
property
is
not
found
or
the
value
cannot
be
updated.
Editor's
note
where
at
least
request.name
Note
that
this
function
is
defined
and
represents
invoked
by
implementations
before
the
name
property
is
updated,
so
the
code
in
this
callback
function
can
invoke
the
readProperty()
method
to
find
out
the
old
value
of
the
Property
property,
if
needed.
Therefore
the
old
value
is
not
provided
to
be
retrieved.
this
method.
5.11
5.15
The
onUpdateProperty()
ActionHandler
method
callback
Defines
the
handler
A
function
for
Property
called
with
a
parameters
dictionary
argument
assembled
by
the
WoT
runtime
update
requests
received
for
based
on
the
Thing
,
as
defined
by
Description
and
the
external
client
request.
It
returns
a
Promise
that
rejects
with
an
error
or
resolves
if
the
action
is
successful
or
ongoing
(may
also
resolve
with
a
control
object
such
as
an
handler
Observable
property
of
type
for
actions
that
need
progress
notifications
or
that
can
be
canceled).
5.16
The
RequestHandler
setPropertyReadHandler()
method
Takes
name
.
The
handler
will
receive
an
as
string
argument
and
readHandler
as
argument
request
of
type
Request
PropertyReadHandler
where
request.name
defines
.
Sets
the
name
of
handler
function
for
reading
the
specified
Property
matched
by
name
.
Throws
on
error.
Returns
a
reference
to
be
retrieved
the
same
object
for
supporting
chaining.
The
readHandler
callback
function
will
implement
reading
a
Property
and
request.data
defines
SHOULD
be
called
by
implementations
when
a
request
for
reading
a
Property
is
received
from
the
new
value
of
underlying
platform.
There
SHOULD
be
at
most
one
handler
for
any
given
Property
and
newly
added
handlers
replace
the
old
handlers.
If
no
handler
is
initialized
for
any
given
Property
.
,
implementations
SHOULD
implement
a
default
property
read
handler.
5.12
5.17
The
onInvokeAction()
setPropertyWriteHandler()
method
Defines
the
handler
function
for
Action
invocation
requests
received
for
the
Thing
,
as
defined
by
the
Takes
handler
name
property
of
type
as
string
argument
and
RequestHandler
writeHandler
.
The
handler
will
receive
an
as
argument
request
of
type
Request
PropertyWriteHandler
where
request.name
defines
.
Sets
the
name
of
handler
function
for
writing
the
Action
specified
Property
matched
by
name
.
Throws
on
error.
Returns
a
reference
to
be
invoked
and
request.data
defines
the
input
arguments
same
object
for
the
Action
supporting
chaining.
There
SHOULD
be
at
most
one
write
handler
for
any
given
Property
as
defined
by
and
newly
added
handlers
replace
the
Thing
Description
.
old
handlers.
If
no
write
handler
is
initialized
for
any
given
Property
,
implementations
SHOULD
implement
default
property
update
and
notifying
observers
on
change.
5.13
5.18
The
onObserve()
setActionHandler()
method
Defines
the
handler
function
for
observe
requests
received
for
the
Thing
,
Takes
name
as
defined
by
the
string
argument
and
handler
action
property
as
argument
of
type
RequestHandler
ActionHandler
.
The
.
Sets
the
handler
function
for
the
specified
Action
matched
by
name
.
Throws
on
error.
Returns
a
reference
to
the
same
object
for
supporting
chaining.
If
provided,
this
callback
function
will
receive
implement
invoking
an
argument
Action
and
SHOULD
be
called
by
implementations
when
a
request
of
type
for
invoking
a
Action
is
received
from
the
underlying
platform.
The
callback
will
receive
a
parameters
dictionary
argument.
There
SHOULD
be
exactly
one
handler
for
any
given
Action
.
If
no
handler
is
initialized
for
any
given
Action
,
implementations
SHOULD
return
error
if
the
action
is
invoked
by
any
client.
request.name
defines
the
name
of
the
Property
or
Action
or
event
Example
7
:
Create
a
new
blank
exposed
Thing
try {
"hljs-keyword">var thing = WoT.produce({ name: "tempSensor" });
// manually add Interactions
thing.addProperty({
name:
"hljs-string">"temperature",
value:
"hljs-number">0.0,
schema:
"hljs-string">'{ "type": "number" }'
"hljs-comment">// use default values for the rest
}).addProperty({
name:
"hljs-string">"max",
value:
"hljs-number">0.0,
schema:
"hljs-string">'{ "type": "number" }'
"hljs-comment">// use default values for the rest
}).addAction({
name:
"hljs-string">"reset",
// no input, no output
}).addEvent({
name:
"hljs-string">"onchange",
schema:
"hljs-string">'{ "type": "number" }'
});
// add server functionality
thing.setActionHandler("reset", () => {
console.log(
"hljs-string">"Resetting maximum");
thing.writeProperty("max", 0.0);
});
thing.start().then(() => {
thing.register();
});
// define Thing business logic
setInterval( async () => {
let mock =
"hljs-built_in">Math.random()*100;
thing.writeProperty("temperature", mock);
let old =
"hljs-keyword">await thing.readProperty("max");
if (old < mock) {
thing.writeProperty("max", mock);
thing.emitEvent("onchange");
}
}, 1000);
} catch (err) {
console.log(
"hljs-string">"Error creating ExposedThing: " + err);
}
Example
8
:
Create
a
new
exposed
Thing
from
a
Thing
Description
"hljs-keyword">let thingDescription = '{ "@context": [ "https://w3c.github.io/wot/w3c-wot-td-context.jsonld", "https://w3c.github.io/wot/w3c-wot-common-context.jsonld" ], "@type": [ "Thing", "Sensor" ], "name": "mySensor", "geo:location": "testspace", "interaction": [ { "@type": [ "Property", "Temperature" ], "name": "prop1", "schema": { "type": "number" }, "saref:TemperatureUnit": "degree_Celsius" } ] }';
try {
"hljs-comment">// note that produce() fails if thingDescription contains error
"hljs-keyword">let thing = WoT.produce(thingDescription);
"hljs-comment">// Interactions were added from TD
"hljs-comment">// WoT adds generic handler for reading any property
"hljs-comment">// define a specific handler for one propertylet name =
"hljs-string">"examplePropertyName";
thing.setPropertyReadHandler(name, () => {
console.log(
"hljs-string">"Handling read request for " + name);
return
"hljs-keyword">newPromise((resolve, reject) => {
"hljs-keyword">let examplePropertyValue = 5;
resolve(examplePropertyValue);
},
e => {
console.log(
"hljs-string">"Error");
});
});
thing.start();
} catch(err) {
console.log(
"hljs-string">"Error creating ExposedThing: " + err);
}
Example
9
:
Create
a
new
exposed
Thing
from
a
TD
URI
"hljs-comment">// fetch an external TD, e.g., to set up a proxy for that Thing
WoT.fetch("http://myservice.org/mySensor/description").then(td => {
"hljs-comment">// WoT.produce() ignores instance-specific metadata (security, form)let thing = WoT.produce(td);
"hljs-comment">// Interactions were added from TD// add server functionality// ...
});
6.
Experimental
extensions
to
be
observed.
the
ConsumedThing
interface
request.options.observeType
This
section
is
of
type
non-normative.
The
RequestType
ThingDescription
and
defines
whether
a
Property
change
or
related
functionality,
such
as
enumerating
Properties
,
Action
invocation
or
event
emitting
is
observed,
or
the
changes
to
the
Thing
Description
s,
Event
are
observed.
request.options.subscribe
is
true
if
subscription
is
turned
or
kept
being
turned
on,
s
and
it
links
(introspection)
is
false
when
subscription
an
API
extension
that
is
turned
off.
out
of
scope
for
this
specification.
However,
the
draft
interfaces
are
defined
here
for
informative
purposes.
Generates
the
Thing
Description
given
Returns
the
properties,
Actions
and
Event
list
of
Properties
defined
for
this
object.
If
a
directory
argument
is
given,
make
a
request
to
register
in
the
Thing
Description
with
of
the
given
WoT
repository
by
invoking
its
Thing
in
the
form
of
a
list
of
register
ThingProperty
Action
.
objects.
5.15
6.2
The
unregister()
getActions()
method
If
a
directory
argument
is
given,
make
a
request
to
unregister
the
Thing
Description
with
Returns
the
given
WoT
repository
by
invoking
its
unregister
list
of
Action
.
Then,
and
s
defined
in
the
case
no
arguments
were
provided
to
this
function,
stop
the
Thing
Description
and
remove
of
the
Thing
Description
.
in
the
form
of
a
list
of
ThingAction
objects.
Stop
serving
external
requests
for
Returns
the
list
of
linked
resources
in
Thing
.
Description
of
the
Thing
in
the
form
of
a
list
of
TDLink
objects.
5.18
6.4.1
The
emitEvent()
TDLink
method
dictionary
Emits
an
the
event
initialized
with
the
event
name
specified
by
the
eventName
argument
Contains
a
hyperlink
reference,
a
relation
type
and
data
specified
by
the
payload
argument.
a
media
type.
The
following
default
events
SHOULD
be
supported
by
ExposedThing
TDLink
implementations:
dictionary
contains
the
following
properties:
"
propertychange
"
of
type
The
PropertyChangeEvent
href
attribute
represents
a
hyperlink
reference
.
"
actioninvocation
"
of
type
The
ActionInvocationEvent
rel
"
descriptionchange
"
of
attribute
represents
a
relation
type
.
The
ThingDescriptionChangeEvent
mediaType
attribute
represents
a
IANA
media
type
.
For
TD
s
there
will
be
registered
media
types,
so
applications
will
be
able
to
check
whether
an
href
link
points
to
a
TD
,
i.e.
whether
the
link
is
fetcheable
with
this
API.
In
addition,
user
defined
events
are
specified
by
the
Thing
Description
.
5.20
7.
Examples
Observables
Below
some
This
section
is
non-normative.
ExposedThing
Observables
are
proposed
interface
examples
to
be
included
in
ECMAScript
and
are
given.
used
for
handling
pushed
data
associated
with
various
possible
sources,
for
instance
events,
timers,
streams,
etc.
A
minimal
required
implementation
is
described
here.
Example
6
Editor's
note
:
Create
a
new
blank
exposed
Thing
This
section
is
informal
and
contains
rather
laconic
information
for
implementations
on
what
to
support
for
interoperability.
The
next()
function,
as
well
as
the
OnNext
callback
takes
the
next
sample
for
the
data
in
the
value
argument.
The
error()
function,
as
well
as
the
OnError
callback
takes
an
error
in
the
value
argument.
It
is
called
when
an
error
occured
in
producing
the
data
the
client
should
know
about.
The
complete()
function,
as
well
as
the
OnComplete
callback
is
called
when
the
data
source
has
finished
sending
values.
7.2
The
:
Create
Subscription
interface
Contains
the
closed
property
of
type
boolean
that
tells
if
the
subscription
is
closed
or
active.
Also,
contains
the
unsubscribe
()
method
that
cancels
the
subscription,
i.e.
makes
a
new
exposed
Thing
request
to
the
underlying
platform
to
stop
receiving
data
from
a
Thing
Description
the
source,
and
sets
the
closed
property
to
false
.
7.3
The
let thingDescription = '{
"name": "mySensor",
"description": {
"@context": [
"http://w3c.github.io/wot/w3c-wot-td-context.jsonld",
"http://w3c.github.io/wot/w3c-wot-common-context.jsonld",
],
"@type": [ "Thing" ],
"interaction": [
// ...
]
// ...
}'
};
WoT.createExposedThing(thingDescription)
.then(function(thing) {
// properties, actions and events are added based on the TD
// ...
});
Observable
interface
The
Observable
interface
enabled
subscribing
to
pushed
data
notifications
by
the
subscribe
()
method:
If
the
subscribe()
method
is
called
with
an
Observer
object,
initialize
the
data,
error
and
completion
handling
callbacks
from
that
object,
or
throw
on
error.
Otherwise,
if
the
subscribe()
method
is
called
with
a
function,
initialize
the
data
handler
callback
with
that
function.
If
the
next
argument
is
provided
and
is
a
function,
initialize
the
error
handling
callback
with
that
function,
or
throw
on
error.
If
the
third
argument
is
provided
and
is
a
function,
initialize
the
completion
handler
with
that
function,
or
throw
on
error.
After
callback
initializations,
the
implementation
should
request
the
underlying
platform
to
provide
data,
error
and
completion
notifications
for
the
supported
data
source.
6.
8.
Security
and
Privacy
Editor's
note
Please
see
the
WoT
Security
and
Privacy
repository
for
work
in
progress
regarding
threat
models,
assets,
risks,
recommended
mitigations,
and
best
practices
for
security
and
privacy
for
systems
using
the
Web
of
Things.
Once
complete,
security
and
privacy
considerations
relevant
to
the
Scripting
API
will
be
summarized
in
this
section.
7.
9.
Terminology
and
conventions
The
generic
WoT
terminology
is
defined
in
[
WOT-ARCHITECTURE
]:
Thing
,
Thing
Description
(in
short
TD
),
Web
of
Things
(in
short
WoT
),
WoT
Interface
,
Protocol
Bindings
,
WoT
Runtime
,
Consuming
a
Thing
Description
,
Thing
Directory
,
WoT
Interactions
,
Property
,
Action
,
Event
etc.
Note
In
this
version
of
the
specification,
a
WoT
Runtime
is
assumed
to
run
scripts
that
uses
this
API
to
define
one
or
more
Thing
s
that
share
a
common
event
loop.
Script
deployment
methods
are
out
of
scope
of
this
version.
In
future
versions,
running
multiple
scripts
(as
modules)
may
be
possible,
and
script
deployment
MAY
be
implemented
using
a
manager
Thing
whose
Actions
permit
script
lifecycle
management
operations.
JSON-LD
is
defined
in
[
JSON-LD
]
as
a
JSON
document
that
is
augmented
with
support
for
Linked
Data
by
providing
a
@context
property
with
a
defining
URI
.
The
term
event
and
the
Event
object
are
defined
in
DOM
and
Node.js
.
Note
This
specification
uses
the
convention
that
an
event
listener
will
receive
an
Event
object.
This
should
work
both
in
a
browser
environment
and
in
a
Node.js
like
environment.
Observable
s
are
proposed
to
be
included
in
ECMAScript.
The
algorithms
utf-8
encode
,
and
utf-8
decode
are
defined
in
[
ENCODING
].
IANA
media
type
s
(formerly
known
as
MIME
types)
are
defined
in
RFC2046
.
The
terms
hyperlink
reference
and
relation
type
are
defined
in
[
HTML52
]
and
RFC8288
.
8.
10.
Conformance
As
well
as
sections
marked
as
non-normative,
all
authoring
guidelines,
diagrams,
examples,
and
notes
in
this
specification
are
non-normative.
Everything
else
in
this
specification
is
normative.
The
key
words
MAY
,
MUST
,
and
SHOULD
are
to
be
interpreted
as
described
in
[
RFC2119
].
This
document
defines
conformance
criteria
that
apply
to
a
single
product:
the
UA
(user
agent)
that
implements
the
interfaces
it
contains.
This
specification
can
be
used
for
implementing
the
WoT
Scripting
API
in
multiple
programming
languages.
The
interface
definitions
are
specified
in
[
WEBIDL
].
The
user
agent
(UA)
may
be
implemented
in
the
browser,
or
in
a
separate
runtime
environment,
such
as
Node.js
or
small
embedded
runtimes.
Implementations
that
use
ECMAScript
executed
in
a
browser
to
implement
the
APIs
defined
in
this
document
MUST
implement
them
in
a
manner
consistent
with
the
ECMAScript
Bindings
defined
in
the
Web
IDL
specification
[
WEBIDL
].
Implementations
that
use
TypeScript
or
ECMAScript
in
a
runtime
to
implement
the
APIs
defined
in
this
document
MUST
implement
them
in
a
manner
consistent
with
the
TypeScript
Bindings
defined
in
the
TypeScript
specification
[
TYPESCRIPT
].
This
document
serves
a
general
description
of
the
WoT
Scripting
API.
Language
and
runtime
specific
issues
are
discussed
in
separate
extensions
of
this
document.
Synchronized
the
Scripting
API
with
the
Thing
Description
specification
.
Defined
ThingDescription
,
ThingTemplate
,
SemanticAnnotations
,
SemanticType
,
SemanticMetadata
,
input
and
output
data
descriptions,
etc.
Special
thanks
to
former
editor
Johannes
Hund
(until
August
2017,
when
at
Siemens
AG)
for
developing
this
specification.
Also,
the
editors
would
like
to
thank
Dave
Raggett,
Matthias
Kovatsch,
Michael
Koster
and
Michael
McCool
for
their
comments
and
guidance.
Encoding
Standard
.
Anne
van
Kesteren.
WHATWG.
Living
Standard.
Kesteren;
Joshua
Bell;
Addison
Phillips.
W3C.
15
December
2016.
W3C
Candidate
Recommendation.
URL:
https://encoding.spec.whatwg.org/
https://www.w3.org/TR/encoding/
[HTML5]
[HTML52]
HTML5
HTML
5.2
.
Ian
Hickson;
Robin
Berjon;
Steve
Faulkner;
Arron
Eicholz;
Travis
Leithead;
Alex
Danilo;
Sangwhan
Moon;
Erika
Doyle
Navara;
Theresa
O'Connor;
Silvia
Pfeiffer.
Robin
Berjon.
W3C.
28
October
2014.
14
December
2017.
W3C
Recommendation.
URL:
https://www.w3.org/TR/html5/
https://www.w3.org/TR/html52/