►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
So
modern
dojo
is
a
progressive
reactive
types
force
framework.
So
we
try
to
leverage
all
the
nice
ergonomic
and
accuracy
benefits
of
type
script
to
create
a
really
nice
fishing's
framework
that
follows
reactive
principles
and
aligns
with
modern
standards
and
gives
you
all
the
things
that
you
typically
need:
out-of-the-box
to
build
an
application
without
being
really
heavyweight,
and
you
know
burdensome.
A
You
might
expect
a
framework
built
today
to
have
so
some
of
the
features
we're
gonna
go
through
we're
gonna
talk
about
how
to
generate
a
custom
element.
That's
nice
enough
that
you
have
to
use
a
custom
element
with
dojo,
but
that
you
know
if
you
create
something
with
dojo
and
then
you
want
to
import
it
into
anything
else
that
recognizes
custom
elements.
You
can
do
that
and
not
sort
of
have
the
burden
of
thinking.
Oh
I
have
to
create
my
whole
application
in
dojo.
A
You
could
just
create
a
big
widget
in
dojo
if
you
wanted
to,
or
similarly,
if
you
created
elements
or
widgets
or
components
or
ever
want
to
call
them
and
other
frameworks,
and
you
want
to
pull
them
into
dojo.
You
could
do
that
through
the
custom
element
approach
as
well.
We
provide
a
really
nice
test,
renderer,
which
we'll
look
at
briefly.
We
use
routing
or
for
your
in
Europe.
You
might
call
that
routing
and
various
other
forms
of
state
management
through
a
dojo
store.
Api.
A
We
have
a
nice
CLI
interface
that
gives
you
really
good
defaults
and
gives
you
commands.
You
need
to
create
dojo
applications,
widget
libraries,
tests
and
other
things.
We
are
able
to
do
a
lot
of
really
interesting
things
because
we
sort
of
know
the
architecture.
That's
there.
So,
for
example,
we
can
do
really
efficient
code
splitting
automatically
we're
using
webpack
under
the
scenes,
but
as
a
developer
of
dojo,
you
don't
care
that
it's
webpack,
you
just
care
that
hey
I've
defined
my
configuration
I've
configured,
some
settings
and
I
get
a
nice
small
default
bundle
size.
A
So
I
get
a
really
nice
fast
application
and
we
also
provide
PWI
support
out
of
the
box.
We
have
this
concept
of
build
time,
rendering
where
you
can
generate
static
sites,
or
you
can
basically
access
and
execute
node
modules
at
Build
time
and
then
load
different
things
runtime
to
create
them
entire
doujin
io
website
itself
is
actually
created
with
dojo.
But
if
you
look
at
the
outputted
source,
you'll
see
little
to
no
JavaScript,
like
the
only
JavaScript.
A
That's
there
is
to
run
our
demos
when
you
need
to
do
that,
and
we
also
have
something
called
dojo
parade
which
is
sort
of
like
storybook,
but
a
little
bit
different,
maybe
not
as
feature-rich,
but
it's
a
first
version.
Basically
a
documentation
and
widget
examples
system
we'll
use
that
as
part
of
the
workshop,
so
we're
covering
a
lot
I'm
going
to
go
ahead
and
stop
sharing
my
screen
and
hand
things
over
to
ant
or
Anthony
and
begin
the
actual
workshop
part
of
this.
B
Hopefully,
everyone
can
see
my
screen
Dylan.
To
give
me
the
nod:
it's
showing
okay,
okay,
cool
Dylan
said:
is
this
dojo?
You
can
do
like
a
lot
of
things,
but
we
thought
it'd
be
cool
to
kind
of
do
a
workshop
on
using
dojo
to
kind
of
build
out
and
build
a
custom
element,
and
so
for
that
what
we're
going
to
do
just
gonna
show
just
one.
B
So
what
we're
going
to
get
to
is
we're
going
build
out
a
weather,
app
that
uses
the
open
weather,
API
I'm,
actually
using
a
proxy
so
that
people
don't
hit
my
rate
limit
but
and
then
build
it
out
as
a
custom
element
and
put
it
in
a
page
and
this-
and
this
is
the
deployed
version
in
on
the
cell.
So
there
we
go.
Oh,
it
worked,
that's
good!
So
so
you
can
basically
check
the
weather.
It's
nicely
weather
like
widget.
B
It's
all
custom
element,
and
this
is
what
this
is,
what
we're
going
to
try
and
build
outer,
and
they
join
the
workshop
with
a
some
bonus
features
as
well
like
being
able
to
kind
of
change
the
theme
of
the
custom
elements
and
change
some
variants.
So
here
this
is
kind
of
a
material
theme
available
from
dojo
widgets,
but
you
can
also
have
a
dark
theme.
That's
probably
very
dark
and
yeah.
So
that's
that's
an
overview
of
what
we
we're
going
to
start
to
build
and
let's
go
back
to
be
as
current.
B
Okay,
so
I
have
put
some
links
in
the
chat.
I
put
together
a
repository
that
everyone
can
clone
if
they
want
to
kind
of
work
along
or
if
they
want
to
build
it,
or
you
know
just
basically
kind
of
have
a
look
through
as
I
attempt
and
to
fumble
my
way
through
live
coding
this,
and
there
are
years
a
few
checkpoints
great
some
tags
that
people
with
they
are
coming
along
and
get
maybe
get
a
bit
left
behind
I'll.
B
Let
you
know
what
you
can
do
a
lot
at
what
point
you
can
kind
of
check
out
what
what's
AG
so
the
first.
The
initial
tag
is
the
workshop
o1
tag,
and
what
this
gives
us
is
a
excuse
me.
It
gives
us
a
kind
of
a
skeleton
project
for
building
widgets
as
a
library
in
dojo,
and
so
we
have
dojo
CLI
and
we
have
various
commands
available,
one
of
which
is
actually
a
command
to
scaffold
a
completely
fresh
new
widget
library
built
with
dojo.
B
So
with
that
with
with
the
template
this-
and
it's
got
all
the
tooling
in
already
pre-installed-
that
you
need
in
order
to
build
your
widgets,
build
your
custom
elements,
but
also
to
be
able
to
kind
of
develop
your
your
widgets
as
you
go
along
and
that's
a
I
think
Dylan
touched
on
it
in
the
intro.
That's
a
module
called
dojo
great,
it's
similar
if
anyone's
familiar
with
storybook.
But
not
you
know
it's
it's
not
the
same.
B
It
gives
a
nice
development
environment
for
you
to
be
able
to
create
examples,
generate
automatically
generate
documentation
based
off
convention
and
typescript
types,
and
also
run
tests.
If
you
have
tests
for
your
widgets
within
your
widget
library,
and
so
I
will
just
quickly
show
you
dojo
Greg,
let's
see
if
I
can
do
this,
so
in
order
to
do
that,
I'm
just
gonna
run
NPM,
Ramdev
and.
B
See
well,
that's
all
good,
isn't
it
I
have
I,
have
an
I
have
an
error.
Okay,
two
seconds,
that's
a
great
start
and
I
will
show
you
that
in
a
minute,
I
need
to
pick
something.
Obviously,
so
let's
just
have
a
quick
look
through
the
air,
the
project,
so
it's
good
I
can
see
it's
now,
everyone's
seen
as
an
error
and
I
migrate.
That's
you
know
sometimes,
and
so
for
parade.
B
So
the
main
thing
to
do
to
just
get
started
is
from
the
V
Dom
module
you
need
to
import
create,
which
is
a
factory
that
is
a
factory
that
generates
you,
a
factory
for
creating
your
functional,
your
functional,
widgets
and
TX,
a
TS
x,
so
that
it
can
recognize
and
trans
bar
down
your
TSX.
And
so
what
we're
doing
here,
I've
got
an
empty
in
space.
I'm,
not
sure
whether
everyone's
familiar
with
typescript
but
dojo
is
is
a
typescript
framework,
so
we'll
be
working
with
types
again.
B
If
anyone
has
any
specific
questions,
police
talking
the
chat
and
I'll
attempt
or
someone
else,
an
out
or
Dylan
will
attempt
to
answer
so.
First
things
first
is
defining
a
factory
for
creating
widgets.
You
could
call
this
say
render,
for
example,
if
you
don't
it's
habitual,
that
call
it
factory
I.
Don't
know
why
so
we're
calling
create
and
then
change
method
which
is
used
to
basically
stamp
the
type
of
the
properties
that
the
widget
can
accept,
which
in
this
case
is
is
nothing
so
we
then
explore
this
widget
with
the
function.
B
A
A
So
in
the
early
days
of
dojo
2
&
3,
&
4,
we
had,
we
supported
something
called
hyper
script,
which
is
similar
to
like
one
of
the
internal
API
is
react,
uses
that
when
you're
not
using
JSX
and
what
we
found
was
that
early
on
it
was
difficult
for
us
to
do
some
of
the
things
we
wanted
to
do
with
typescript
in
terms
of
defining
really
good
functional
API.
So
a
lot
of
our
API
is
early
on,
used
es6
classes
and
used
this
sort
of
function.
A
Signature
API
that
is
effectively
the
same
as
tsx
is
just
it's
written
out
as
like
a
function
with
three
parameters
rather
than
a
TSX,
which
is
just
JSX
wrapped
in
typescript
syntax.
But
as
we've
evolved,
we've
found
that
most
of
our
users
and
most
of
our
team
are
finding
it
more
flexible
and
a
bit
more
powerful,
a
bit
more
efficient
to
write
things
as
tsx
and
a
lot
of
that
has
to
do
with
tooling,
where
it's
hard
to
know.
A
If
you
have
an
error
unless
like
in
what
is
conceptually
markup
or
parameters
for
a
component,
if
you
don't
have
two
linked
support
to
point
out
where
you,
where
you've
made
a
mistake,
and
so
because
typescript
has
gotten
so
good
at
supporting
JSX
and
TSX,
and
then
tools
like
vs
code
and
other
things
that
support
the
typescript
language
services
have
gotten
quite
good
at
that.
We've
decided
that
most
of
the
time,
we
prefer
writing
things
in
this
tsx
syntax
and
also
it's
a
lot
more
familiar
to
people.
A
Who've
used
to
react
to
hey,
I'm
just
going
to
use
a
very
similar
syntax
to
what
I'm
used
to
doing
with
react,
so
that
was
kind
of
the
main
reason
we
made
that
shift.
It
dojo
always
supported
that
CSX
insects
from
the
2.0
release,
but
it's
kind
of
become
our
preferred
approach.
As
of
doja
version,
6
I
said
enough
distraction
for
you
are
you.
B
So
yeah
I
mean
so
so,
basically
a
lot
a
lot
of
the
the
tooling.
We
have
here,
we've
kind
of
kind
of
dog
food
ourselves
as
much
as
possible
on
the
in
the
dojo
widgets
repository
and
package.
So
all
of
the
tooling
that
we've
made
up,
we
basically
using
all
the
tooling
available
to
external
users
internally
in
order
to
build
and
test
and
develop
and
publish
our
in
our
official
dojo
widgets
library.
And
yet
this
isn't
working.
So
that's
great.
B
B
Yeah
you
mean
they
just
have
you're
a
robot,
yeah,
okay,
so
I'm
gonna
just
get
started
with
with
the
workshop
rather
than
stuffing
around,
and
hopefully
I
will
get
this
fixed
during
the
workshop.
You
know,
as
you
do
so.
Hopefully
that
was
a
kind
of
a
brief
overview
of
the
the
initial
kind
of
template.
B
B
Type-Ahead
requires
a
resource
so
that
it
can.
It
doesn't
know
anything
about
the
actual,
the
external
data
we
can
transform,
that
into
the
the
payload
that
we
need
for
for
the
type
of
head
than
the
type
a
head
and
can
deal
with
that
resource
agnostically
and
not
actually
have
any,
not
need
to
know
anything
specific
about
kind
of
the
type
of
resource
there's.
So
it's
that
the
first
thing
I'm
going
to
do
is
I'm
going
to
import
I.
B
Think
it's
I
think
it's
the
default
great
resource
middleware
and
it's
again
another
Factory.
We
do
like
factories
because
they
give
us
some
power
to
be
able
to
kind
of
add
Taipings
to
like
stamp
Taipings
onto
onto
like
or
dojo
kind
of
modules
or
functions,
and
that
helps
us
kind
of
remove
typings
from
the
end
user
as
much
as
possible,
rather
part
from
their
in
their
own
widgets.
So
let's
go
middleware.
B
Was
a
name
I
should
know
that
right.
So
the
first
thing
we
need
to
do
is
to
we
need
to
create
the
middleware
and
for
our
usage
here
we
just
need
to.
We
don't
need
to
pass
anything.
We
don't
need
to
pass
any
like
a
generic.
So
basically,
if,
if
you
pass
any
type
to
this
middleware
factory,
it
will
in
it's
a
proxy
on
to
your
widget,
so
that
it
tells
it
that
tells
the
consumer
that
it
needs
to
have
take
a
resource
in
order
to
function.
B
B
Okay,
like
that,
and
that
and-
and
that
would
be
that
would
apply
a
resource
property
on
to
the
widget
instead
of
you
having
to
define
it
in
in
Europe
like
manually,
defining
yourself.
That
automatically
applies
once
you've
passed
once
you've
applied
to
the
middleware
to
the
to
the
factory
factory.
So,
in
order
to
use
this
resource
middleware,
we
need
to
pass
in
an
object,
so
it
takes
an
object
of
middleware,
so
you
can
have
multiple
middlewares
and
middlewares
can
use
middlewares
and
they
can
be
composed
up
with
multiple
like
they
can
be.
B
The
functionality
can
be
composed
together
in
that
in
such
a
fashion,
and
what
this
does
is
this
tells
dojo
to
inject
the
reason
I,
like
the
natural
resource
function
into
your
widget,
so
you
can
use
it
there.
You
can
use
it
in
your
widget
and
again
that's
passed
in
as
the
arguments
into
the
your
widget
and
that
is
using
middleware.
So
it's
passed
in
in
the
middleware
and
I'm
going
to
do
structure
the
resource
off
it
like
that.
So
that
allows
that.
B
So
this
is
the
actual
resource
that's
injected
into
our
weather,
widget,
which
we're
going
to
use
when
we,
when
we
start
using
the
chip,
side,
bed,
okay
and
cheap,
to
use
to
use
a
resource
as
I
said
earlier,
is
the
resource
is
its
kind
of
it
leverages
effectively
as
like
a
static
template
that
your
users
can
define
and
and
and
describe
how
to
fetch
data?
For
that
particular
resource,
so
I'm
gonna
create
I'm
gonna.
B
B
C
B
Go
let's
just
put
in
find
as
well,
so
hopefully
it
will
stop.
Complaining
will
do,
but
probably
will
find
it
in
a
minute
there.
We
go
so
that
fulfills
that
there,
our
template,
API,
so
every
resource
needs
to
have
at
the
moment
to
API,
is
something
that
we
are
looking
to
improve
on
in
dojo
seven.
This
was
the
first
iteration
of
resources
to
provide
you
to
provide
kind
of
a
reader,
the
read-only
side
of
working
with
external
resources.
B
You
know
in
the
next
few
versions
of
dojo
we're
hoping
to
kind
of
expand
that
you
know
expand
some
of
the
fine
grained
control,
implement
some
kind
of
some
operational
data
and
working
with
a
few
errors
and
handling
handling.
Basically
more
of
just
more
of
these
scenarios
for
the
complete
resource
experience.
B
So
with
the
read
function,
you
get
a
request
and
the
request
is
telling
it's
going
to
explain
a
minute,
but
that's
basically
telling
you
what
you
know.
What
whatever
is
calling
this
resource
needs
that
will
be
that
contains
things
like
queries,
pagination
details
and
the
likes
like
that,
and
then
you
get
a
second
argument
called
controls
injected.
Let's
make
it.
Let's
call
it
controls
and
controls
allows
you
to
interact
with,
like
the
backing
store
behind
resources.
So
resources
are
a
global
pressure
application
so
it
meaning
that
you
have
effectively
have
you.
B
Can
it
caches
your
controls,
the
caching
of
your
of
your
resource
and
throughout
the
application,
so
that
you
don't
find
yourself
having
to
like
make
like
thousands
of
requests
for
the
same
thing
all
of
your
application?
So
the
next
thing
we
need
to
do
is
and
and
so
with
the
controls,
the
controls
you
can.
B
Actually,
you
can
actually
fetch
data
that
already
exists
in
the
store,
if
you
need
which
we
don't
need
to
do
today,
but
also
the
other
control
which
is
important
to
us
is
the
put,
and
the
put
is
how
the
read
function
or
the
read
function
of
the
template.
Basically,
it's
what
it
is
store
is
what
it
puts
into
the
backing
store
for
that
particular
request,
and
so
let's
go
out.
Let's
go
ahead
and
build
out
this
read:
template
and
I'm
gonna
do
I'm
gonna
D
structure.
B
I'm
using
a
quiet
keyboard,
which
means
that
I'm
not
very
good,
I'm,
gonna,
D
structure,
some
of
the
details
of
requests
and
that's
I,
think
off
set.
It
provides
an
offset
rather
than
actually
page
number
and
offset
which
you
can
convert
to
page
number.
If
you
need
to
for
your
API
size
of
paper,
that's
the
page
size
and
a
query
which,
basically
is
the
is,
if
you
need
to
filter
down
so,
for
example,
or
type-ahead.
B
If
you,
if
the
user
starts
typing,
it's
going
to
give
you
the
value
that
it
wants
to
filter
down
low
and
I'm
gonna
have
to
copy
something:
a
minute:
cuz,
a
contra
member,
this
URL
Apple
and
thanks
glitch.
So
this
is
the
URL.
Let
me
put
that
in
chat
just
in
just
in
case
anybody's
following
along.
They
might
not
be
that's
fine
too.
C
B
C
B
This
is
where
we
use
the
controls
to
put
the
results
of
that
request.
Actually
we'll
do
completely,
and
what
that
takes.
Is
that
takes
a
an
object
which
has
the
data
and
the
total
and
the
total
is
optional.
So,
but
in
this
case
I've
made
my
API
provide
me
with
that
exactly
over
that
exact
shape,
so
that
works
to
me
and
then
the
second
second
part
of
that
is
the
request,
and
that
says
resources.
You
know
what
this
data
is,
what
request
this
data
score.
B
So
at
this
point,
we've
built
out
our
capital
city
template
and
we're
not
actually
using
the
find
API,
but
we
do
have
a
default
find
which
we
provide,
which
operates
on
the
data
that
the
resource
is
aware
of
rather
than
the
so
rather
than
the
the
restful,
the
REST
API.
So
that
will
do
for
us
the
moment
so
the
capital
city
template
so
now,
we've
connection
so
fatica
long
time.
So
now
we
can
actually
start
to.
We
can
import
our
chip,
wisdom,
chip,
widget
from
dojo
widgets.
B
And
then
we
can
start
to
use
it,
so
we're
going
to
replace
we're
gonna,
replace
the
contents
of
this
div
and
we're
going
to
put
in
chip
type
and
now
that's
obviously
requires
some
properties.
So,
as
I
said
earlier,
we
know
that
we
needs
a
resource
property,
so
we
will
use
resource
middleware
and
we
will
parse
in
I,
really
use
the
resource
middleware
and
pass
in
the
template,
which
is
the
capital
city
template,
and
that
should
be
all
you
need
for
it
to
operate
with
resources.
C
B
B
B
B
B
So
if
we
do
this,
it's
going
to
take
a
property
of
string
array
and
it's
also
going
to
take
a
function
which
is
going
to
pass
the
values
the
currently
selected
values
from
the
type-ahead,
and
that
should
be
enough
at
a
minute
and
we'll
make
this
optional.
So
that
means
what
we
can
do
and
so
it's
looping
back
to
properties.
Obviously
the
properties
were
defined
by
passing
api
here
and
in
this
set
in
the
same
way
as
the
middleware
properties
are
injected
into
the
widget.
B
B
Ish,
okay,
cool!
So
that's
really
all
we
need
to
do
in
order
to
to
put
the
type
a
head
into
our
widget
to
leverage
resources
to
in
order
to
work
with
the
chip
hyper
head
to
interact
with
external
restful,
api
and
and
then
return
and
basically
return.
Our
location
results
that
we're
going
to
use
later
to
actually
like
display
the
weather.
So
that's
so
relieving
back
to
our
examples
in
parade,
and
so
obviously
I've
added
a
couple
of
properties
here.
C
B
B
B
So
in
this
case
it's
just
an
empty
string,
so
I'm
going
to
pass
in
locations
here
and
and
with
the
unchanged
I'm
going
to
take
the
values
that
are
passed
to
me
as
we've
defined
in
our
widget
and
pass
through
in
a
widget,
and
let's
go
back
just
to
the
look
as
we've
done
here
and
the
values
from
the
Chipola
bed
and
I'm,
going
to
I
cached
or
set
again
using
the
same
key
locations
and
set
those
values.
And
that's
because
there
we
go
so
now.
B
B
C
C
C
B
Okay,
so
we've
got
through,
so
this
is
so
if
anyone
is
attempting
to
follow
on
I,
do
apologize
that
probably
took
quite
quickly
on
account
of
not
really
being
able
to
know
how
people
are
doing
and
also
talking
quickly
just
generally
and
we
are
are.
This
is
the
next
stage
is
workshop.
If
you
want
to
catch
up
and
just
be
somewhere
similar,
if
you
want
to
check
out
that
tag,
they
workshop
OH-
that
is,
okay,
so
assuming
I've
got
things
right,
which
is
a
big
assumption,
see
if
that
works.
B
We
are
going
to
basically
now
build
out
the
details
of
with
the
weather
part
of
our
widget.
So
for
that
I'm
going
to
create.
Let
me
close
this
because
it's
really
getting
in
the
way
I'm
gonna
create
a
new
widget
called
weather
details,
a
new
reason,
a
new
resource
template
that
will
interact
with
the
API
to
get
the
weather
details
for
a
specific
location
and-
and
that
should
learn
that's
about
it
than
that
so
I've
already
so
I'm
going
to
be
using
some
CSS
in
this
particular
case.
B
C
B
Okay,
so
so
okay
get
back
to
it,
so
we're
going
to
build
out
the
the
details,
part.
Actually,
the
you
know
the
actual
the
weather
for
the
sit
for
each
of
the
locations.
So
we
need
to
create
a
new
factory
that
we're
going
to
use
I'm
going
to
create
it
above
here.
So
it's
gonna
be
up
here.
Obviously
can't
use
factoring
that's
going
to
be
weather
details.
B
B
B
B
B
We're
gonna
work
with
properties
and
resource
resource
in
the
same
way
here
what
in
not
missing
in
same
way
but
and
we're
going
to
work
with
those
two
things
again
when
we're
building
out
this
up
this
part
of
the
widget.
So
the
first
thing
we
want
to
do,
let's
get
our
location
from
our
properties
and
then
we're
going
to
return
some
tsx
to
describe
the
weather
yay.
B
So
that's
almost
certainly
going
to
start
with
I
did
attend
date.
There
we
go
so
in
in
in
the
weather,
details
where
you
get
wicket
in
the
past.
The
look
at
the
location,
but
we're
going
to
have
to
build
a
similar
template
for
to
be
able
to
get
to
be
able
to
leverage
resources
in
order
to
get
the
weather
for
that
location.
So
I'm,
just
gonna
Nick.
This.
C
C
B
B
Complete
your
CSS,
so
it
helps
with
not
having
to
one
remember
the
your
class
names
and
to
mistyping
your
class
names
that
you
know
all
the
benefits
of
the
general
water
completion
for
in
typescript,
which
is
cool,
and
so
it's
still
I'm
still
wearing
store,
no
modules.
So
that's
that's.
Why
that's
doing
that?
Okay,
so
we're
gonna
build
up
the
the
weather
template
in
the
same
way
as
we
go
out.
The
capital
city
template
we're
going
to
get,
and
in
fact,
but
the
main
a
copy.
This
is
the
payload.
B
The
actual
the
resource
itself
is
not
just
a
value.
It's
going
to
have
all
the
information
we
need
in
order
to
display
the
weather.
In
this
case,
it's
my
weather
details.
So
it's
got
a
name
which
is
the
name
of
the
city,
the
temperature,
the
max
temperature,
the
min
temperature,
an
array
of
descriptions
and
an
icon
to
display,
and
so
passing
that
to
the
resource.
Template
tells
anything
that
uses
this.
B
B
So
the
first
thing
I
need
is
my
options
and
so
I'm
gonna
call
create
options
and
for
this,
I
need
to
actually
pass
in
an
ID
and
each
widget
gets
injected
in
a
unique
ID
that
you
can
use
for
thing
for
cases
like
this.
So
that
will
be
the
same
for
the
lifetime
of
the
widget,
and
so
that
will
give
us
the
the
same
options
back
once
they're
initially
created.
B
And
then
the
next
thing
is
we're
going
to
or
get
or
read
with
weather
template
and
we're
going
to
pass
in
the
options
and
the
options
is
a
function
that
you
need
to
call
which
will
return
the
current
options,
but
that
can
also
take.
It
can
also
take
an
object,
a
partial
of
the
options
so
that
you
can
patient
on
the
page
size
and
also
set
the
query
in
this
case
we're
setting.
We
need
to
set
the
query
so
that
we
can
sell
the
template,
which
location
to
look
at
and
so
I'm
going
to
do.
B
B
And
it's
gonna
looks
just
like
that:
I
think
and
I'm
still,
installing
no
modules.
That's
why
everything's
gone
wonky
I
mean
oh
I'm,
surprised
it
hasn't
killed
my
wrist.
My
internet
and
resources
return
an
array
of
pages,
because
resources
can
support
returning
multiple
pages.
So
what
we're
going
to
do
is
we're
going
to
take
the
weather
details
from
here
we're
going
to
D
structure
the
first
item
from
the
array.
B
C
B
B
B
Aha,
look
it
kind
of
didn't
fail.
I
still
need
to
do
my
template,
of
course,
because
that's
not
going
to
do
anything
so
we're
going
to
build
that
out
in
the
same
in
the
similar
way.
So
we've
got
a
request
on
our
controls.
So
let
me
I,
don't
know
this
gyro
either
it's
long
so
I'm
going
to
paste
this
in
here.
C
C
C
B
C
B
Just
gonna
have
to
build
the
build
the
because
Melanie
yeah
and
that's
the
way
we're
gonna
have
to
check.
Hopefully
if
anyone's
following
along,
they
are
having
better
success.
I'm
not
sure,
what's
happened
here,
okay,
so
we've
built
out
our
work
of
details
and
it's
it's
pretty
standard.
It's
some
divs
with
some
classes
to
kind
of
lay
out
the
information
we've
got
the
name
of
the
city,
max
temp,
mint,
M,
the
description
of
from
the
open
weather,
API
and
then
the
main
temperature.
B
B
C
B
So
we're
going
to
skip
a
couple
of
steps
because
I'm
going
to
actually
build
this
as
a
custom
element
and
so
that
we
can
actually
see
something
and
see
if
it
works
and
that's
harder
to
debug.
If
I'm
got
this
wrong
so
with
the
bill
tooling,
for
building
a
widget
library
with
all
of
our
all
of
our
CLI
commands,
we
have
a
dojo
see
we
can
specify
configuration
for
everything
so.
B
B
There
we
go
okay,
there
we
go
so
we
have
a
dojo
RC
configuration
file
and
if
I
was
actually
able
to
to
show
you
parade,
we,
the
dojo
RC
configuration,
extends
a
configuration
provided
by
parade
in
order
to
build
properly,
but
the
bit
we're
interested
in
right
now.
So
we
can
try
and
build
our
custom
element.
Is
this
build
widget
with
a
prefix,
a
build
Ridgid
section,
and
this
rule
this
tells
the
C
light.
So
the
dojo
CLI
build
widget
command,
which
widgets
to
build
and
for
custom
elements.
B
Ok
and
let's
also
add,
if
there's
going
to
be
some
so
when
we
build
this,
it's
going
to
be
put
into
the
output
directory.
So
I've
just
got
a
index.html
file
here,
which
I'm
up
there
here
that
I'm
going
to
be
using
in
order
to
like
demo
the
custom
element
and
so
I'm
going
to
import
the
CSS
that
we
generate
for
the
poster
moment
for
the
whether
custom
element
I'm
also
going
to
import
the
JavaScript
for
libel,
which
is
the
bit
down
here.
So
that's
the
JavaScript
and
then
what
we're
going
to
do
is
I.
C
B
And
in
that,
we're
going
to
use
our
dojo
with
a
that's,
but
your
should
remember,
or
hopefully
remember,
that
the
doji
weather
widget
itself
in
dojo
requires
some
properties,
so,
for
example,
it
requires
location
at
least,
and
an
unchanged.
So
what
we're
going
to
do
is
we're
going
to
provide
it
with
some
locations
and
not
provided
with
an
unchanged
so
that
we
can
see
whether
this
works.
So
you
won't
have
actually
got
this
running.
B
Let's
give
this
an
ID,
so
I
can
reference
it
later
and
you'll
notice
that
the
actual
type
of
the
locations
is
isn't
like.
Isn't
the
primitives
like
a
boolean
or
a
string
or
a
number,
so
with
the
custom
elements
support
in
dojo4,
we
can
support
complex
properties
by
passing
in
a
adjacent
string,
fide
version
of
illustration,
stringify
string
of
the
complex
property
and
you'll
also
notice
that
I've
not
done
anything
in
order
to
kind
of
tell
the
build
tooling,
you
know
what
properties
the
the
widget
has
will
requires
so
or
what
types
they
are.
B
So
how
does
it
know
the
locations
is
something
that
it
might
get
past
as
a
adjacent
string
of
five
string,
and
that
is
part
of
the
building
where
we
can
and
we
can
look
at
the
properties
during
build
time
to
determine
what
the
types
are
of
the
properties
and
then
deal
with
them.
Accordingly,
within
the
the
output
compiled
custom
moment,
okay,
I
can
never
get
this
right,
so
I'm
just
going
to.
B
C
B
B
Okay
and
that's
because
I
need
to
check
whether
or
not
it's
undefined,
because
it's
not
necessarily
going
to
have
those
properties
if
I've
done
it
wrong,
so
I'm
just
going
to
default
it
just
in
case
and
rebuild
it's
the
time,
10
past
good,
looking
and
given
all
the
how
come
all
the
problems,
not
looking
too
bad
on
time.
No,
we
don't
show
you
anything
though,
but
in
my
clip
server
is
now
dead.
C
B
B
What
we're
going
to
do
is
we're
going
to
register
an
event
listener
and
we're
so
we've
custom
elements
dojo
also
automatically
finds
functions
that
are
prefixed
with
on
and
converts
them
into
event.
Listeners
that
you
can
attach
to
within
your
HTML,
using
when
you're
using
the
custom
moment,
so
we're
going
to
create
scripts.
C
B
B
B
Aha,
something
this
is
our
custom
element
and
so
we're
going
to
add
some
some
nice
sugar
that
it's
available
to
our
dojo
widgets,
which
is
some
theming,
so
we're
going
to
basically
add
the
add,
the
material
themes
it's
available
from
dojo
widgets
and
the
we
can
add
the
the
dojo
theme
as
well.
We're
going
to
also
add
some
buttons
to
kind
of
pre
populate
the
the
list
in
this
case
London.
So
hopefully,
if
I
did
another
one.
Oh
look
it's
details
and
no
touch
script.
B
To
save
me,
there,
unfortunately
yeah
so
we're
going
to
add
a
button
to
pre
populate
the
list
and
and
we're
also
going
to
other
extra
bits
functionality
to
be
able
to
make
this
read-only
so
that,
if
you
don't
want
to
have
the
drop
down,
it
won't
show
the
drop
down
and
it
will
just
populate
the
specified
locations
as
a
read-only
kind
of
widget,
not
miss
minchin
and
don't
know
whether
or
not
okay
don't
worry
about
it,
no
worries
and
okay.
So,
let's
carry
on
first
things.
First,
this
is
detail,
and
that
is
detail.
B
Okay,
so
that
would
work
now.
So
what
we're
gonna
do
is,
as
I
said,
is
we
can
all
of
our
custom.
Elements
can
basically
can
take
themes,
so
in
this
case
we're
going
to
because
we're
leveraging
the
dojo
type-ahead
and
we
haven't
created
a
theme
for
our
weather
widget,
which
we
could
have
done,
but
didn't
really
think
the
other
time
and
obviously
everything
gone
so
well.
So
it's
probably
good.
B
We
didn't
so
we're
going
to
create
the
we're
gonna
add
in
the
CSS
and
the
and
state
and
specify
the
theme
and
we're
gonna
use
a
couple
of
other,
just
those
your
widgets,
that
we
distribute
it's
custom
elements
that
you
could
just
use
in
your
page.
So
let's
just
do
that
and
I'm
going
to
just
steal
the
you
don't
mind
so
we're
going
to
add
we're
going
to
use
some
buttons
from
dojo
dojo
at
dojo
widgets
we're
going
to
use
the
material
theme
and
the
dojo
theme.
So
we
just
need
this
CSS.
B
So
that's
the
CSS,
so
I
move
I've
as
part
of
the
bill
that
I'm
moving
this
into
my
output
disk
folder.
So
it's
so
I
can
reference
it.
So
it's
the
this
is
the
dojo
theme
and
the
material
theme
and
then
the
CSS
for
them
for
the
custody.
Don't
dojo
button,
custom
elements
that
was
a
mouthful
and
also
going
to
take
the
JavaScript
so
body.
B
So
we're
going
to
add
the
there's
JavaScript
each
of
the
the
themes
have
a
small
wrapper
to
be
able
to
set.
It's
basically
set
the
available
themes
for
custom
elements,
so
in
this
case
the
dojo
javascript,
the
material
javascript
and
obviously
the
the
button
javascript
that
we
need
for
the
custom
element
itself.
B
A
B
And
so
I
just
rebuilt
thee,
I'm
gonna
start
doing
that
in
the
in
the
terminal
in
the
s
code,
so
you
can
see
but
I
just
rebuilt,
so
hopefully
I.
So
what
we
did
there
is
we
so
we
internally
and
our
widget
we're
using
the
dojo
type
head.
So
that
means
that
it
will
we
wear
if
you
set
the
theme
to
be
the
material
theme
for
or
the
dojo
tone
that
will
get
passed
down
and
propagated
through
to
any
theme,
Abul
widgets
that
you
are
using
in
your
custom
element.
B
So
in
this
case
we've
got
the
material
theme,
which
is
it's
just
as
here,
and
we
now
have
a
material
themed
type.
It
that
looks
a
lot
nicer,
I
think
well,
I
mean
bearing
in
mind
I,
haven't
been
able
to
run
parade
and
check.
This
I'm
suitably
impressed
what
a
train
in
Andorra,
okay
cool
right.
So
let's
have
a
look
at
what
we
need
to
do
so
as
well
as
as
well
as
theming
as
of
dojo
seven,
we
introduced
concept
to
it.
B
Well,
we
introduced
a
concept
of
variants
that
could
be
switched
at
runtime
so
that
supported
for
all
of
our
I
believe
all
of
the
widgets,
our
dojo
widgets,
and
so
we
have
a
dojo
theme
and
a
material
thing,
but
we
also
have
light
and
dark
variants.
The
light
is
the
default
which
it
will
be
used,
as
you
can
see
here
by
default.
So
what
so?
First
things.
First,
I
guess
what
we
should
do
is
add
a
button.
B
B
I
can
become
so
obviously
it's
a
button.
So
if
we
look
at
so,
I
can
actually
show
you.
Let's
have
a
look.
This
is
those
your
parade
for
dojo
widgets.
So
this
is
what
it
should.
I
would
only
have
one
widget
for
the
for
the
example,
but
you
can
see
here.
This
is
the
the
main
landing
page
gives
a
brief
overview
of
how
to
install
don't
your
widgets,
how
to
use
don't
your
widgets
and
the
butter
here
and
and
some
some
features
around
those
your
widgets
and
then
down
the
side.
B
Here
we
have
each
of
our
widgets.
We
have
available
within
the
within
the
suite.
So,
for
example,
if
we
let's
have
a
look
at
the
chip
side,
because
that's
what
we're
using
so
the
there's
a
landing
page
with
some
in
some
extra
information
on
the
chip
type-ahead
an
example
which
is
normally
just
a
very
basic
example
on
the
home
page.
B
B
This
is
quite
familiar
as
we've
got
a
chip
type-ahead
resource
we've
got
a
label,
there's
slightly
different
uses
for
resource,
because
it's
using
an
array
of
data
rather
than
a
external
resource,
and
then
all
the
properties
for
the
resource
so
and
as
much
as
well
as
that,
the
the
children
that
can
be
passed
to
the
resource
and
also
anythi
mobile.
So
if
dojo
io
learn,
this
should
there's
some
sections
about
starting
and
theming,
and
so
you
can
create
themes
for
any
of
these
widgets.
B
If
you
don't
like
the
dojo
one
or
if
you
just
want
to
enhance
it
in
in
some
way-
and
these
are
all
the
theme
herbal
classes
that
you
would
need
to
need
to
use.
So
this
is
kind
of
an
overview
of
all
the
different
information
and
documentation
for
the
widget.
This
is
effectively
the
public
API
being
the
properties,
and
then
we
have
so
so
also
in
parade.
You
can
change
the
theme,
there's
a
number
of
themes.
You
can
have
multiple
different
examples,
so,
for
example,
this
is
a
disabled.
B
Look
there
you
go
yeah,
and
so
so
this
is.
This
is
all
of
the
different
widgets.
So
please
check
out
which
is
widget,
dojo,
dot,
IO,
it's
pretty
it's!
Its
new
parade
was
only
released
and
you
know
a
month
or
two
ago
and
so
said
beforehand
we
actually
manually
kind
of
maintained
all
the
documentation,
so
we're
moving
away
from
that.
So
people,
please
control
to
give
feedback
and
and
that'd
be
great,
and
this
is
what
we
wanted
to
kind
of
show
you
earlier
with
the
weather,
widget.
C
B
So
what
we're
going
to
do?
Sorry,
I,
don't
know
why
I
went
on
a
big
tangent
there,
and
but
that's
why?
Because
I
was
going
to
show
you
the
button
and
so
from
from
this
documentation
you
can
see
the
properties,
so
you
know
got
long.
Click
and
you've
got
all
the
other
events
that
you
might
need
and
so
type
you
know
some
area.
So
you
can
pass
them
to
your
accessibility
if
you
need
and.
B
Thing
so
we're
gonna
use
the
idea
again,
you
can
add
an
event
listener
for
the
click.
So
when
the
button
is
clicked
and
what
we're
gonna
do-
and
this
is
so-
women
live
custom
elements
when
you
load
in
the
JavaScript.
It
registers
themes
on
global,
called
dojo,
s--
dojo
seee,
which
is
what
you
can
use
in
order
to
set
and
change
and
introspect
the
available
themes.
And
so,
in
this
case,
what
we're
going
to
do
is
we're
going
to
do
if
and
just
double
check
what
I
did
here
that
looks
good.
B
Okay,
so
no
we
should
have
a
button
and-
and
it
should
talk
while
I
think,
let's
have
a
look.
That's
the
wrong
one!
That's
great!
That's!
Never
gonna
work,
aha,
so
yep!
So
we're
now
changing
the
theme
for
our
custom
element.
So
in
this
case
we
don't
have
a
theme
for
our
weather
widget,
but
we
do
have
a
theme.
We
are
changing
the
theme
for
the
the
dojo
chip
type-ahead
and
you
can
also
see
obviously
that
changes
the
theme
for
the
button
as
well.
B
B
C
B
B
C
B
B
B
B
B
And
so
what
did
Dora
well?
Secondly,
can
last
until
we
had
a
final
bit
of
functionality
for
a
read-only
weather
widget
and
we
populate
our
locations
and
look
I,
didn't
I,
didn't
I,
didn't
push
the
boat
out,
I'm,
trying
to
guess
capital
cities,
thankfully
so,
and
then
you
can
continue
to
use
the
type
of
head
functionality
and
don't
know
why
that's
happening.
That's
annoying.
Okay,
next
thing
is
so
that's
that
brings
us
like
right.
Nearly
to
the
end
of
of
the
custom
element
workshop,
we
have
I've
struggled,
but
I've
got
two
have
built
yeah.
B
We
built
a
custom
element
in
dojo.
The
leverage
is
kind
of
the
new
resource
concept
is
the
way
to
interact
with
external
resources
and
to
make
widgets
data
are
we're.
Generally,
you
know
from
version
7
we've
used
new
dojo
widgets
chip
type-ahead
to
provide
us
kind
of
nice
functionality
and
we've
also
like
created
our
weather,
widget
and
we've
configured
the
project
to
build
as
a
custom
element
that
we
could
then
distribute
out
and
people
could
use.
Obviously,
this
is
this
is
using
my
my
proxy,
but
you
know
in
real
life.
You
would
this.
B
You
could
replace
this
with
the
real
API
is
to
say
open,
API
and
you
not
only
could
take.
You
could
take
an
API
key
for
the
sort
of
property
and
you
could
use
that
API
key
within
your
resources,
and
so
therefore
it
would
work
for
anybody
who
wants
to
you
know
if
you
publish
this
and
you
know
NPM
or
whatever,
and
people
could
use
this
as
they
need
it.
So
we,
but
we
don't
need
to
do
that
because
we're
not
using
real
API.
So
but
that's
you
know
you
can
demand
and
there's
lots
more.
B
You
can
do
with
with
any
API,
but
specifically
for
whether
you
know
you
could
you.
Could
you
have
five
day
forecast
three
day
one
day
forecast
three
day
forecast
you
could
provide.
You
know
all
sorts
of
you
could
have
all
sorts
of
properties
to
kind
of
control
that
configuration.
If
you
want
it
to
extend
out
this
widget
to
provide
more
information
and
the
last
thing
we're
going
to
do.
We
are
going
to
add
a
new
property,
it's
going
to
be
called
read-only
and
it's
going
to
be
optional
and
it's
going
to
be
a
boolean
and.
B
Yes,
well,
we
only
get
show
it
if
it
only
gonna
show
that
so.
Yes,
sorry,
my
god,
so
if
it's
read
only
then
it
won't
show
the
chip
tie
bed.
If
it's
not
really
only,
then
it
will
show
sugar
typo
bed
and
by
deeper
we
will
show
they
type
the
chip
type
heads.
So
let's
we're
gonna
have
to
build
this
against
and
it's
soon
if
it
will
build
him
in
mile
terminal,
yeah.
C
C
C
B
And
there
we
go
so
we're
not
showing
the
so
if
we
talk
whether
we
only
we
don't
show
the
excuse
me
the
chip
by
bed
or
the
city
selection,
but
we
can
still
populate
locations.
So
if
we
were
to
let's
go
back
here
so
if
we
were
to
go
start
off
with
locations
like
we
did
earlier,
which
would
be
let's
say,
London.
B
B
One
thing:
I
guess:
I
didn't
really
show
because
I
didn't
have
the
opportunity
in
parade,
but
with
the
resources
and
the
type-ahead
when
you're
working
with
paginate
'add
requests,
we
the
type
of
head
itself
or
resources,
will
fetch
a
page
at
a
time
and
will
fetch
the
the
pages
as
as
the
user
Scrolls.
So
you
can
add
lots
more.
So
I
think
there's
like
two
hundred
and
fifty
here
once
they
obviously
loaded
they're,
loaded
and
cache.
So
it
doesn't
need
to
make
a
request
again.
B
B
B
B
So
this
this
is
why
I
wanted
to
show
earlier.
Let's
see
if
actually
there
we
go
so
this
is
the
me
claves
lift
or
simply
there
we
go.
So
this
is
the.
This
is
what
you
get
out
the
box
when
you
use
the
outlets
and
the
present
reason
bit
rebuilding
rebuild,
but
it's
what
you
get
out,
the
Box
you
get
all
the
niceties
of
what
we
the
the
documentation.
So
you
can
see
here,
it's
I
didn't
add
any
documentation
it.
It
is
there
on
my
main
branch.
B
I
just
was
lazy
during
the
during
this
when
I
was
at
work
during
the
workshop,
and
so,
if
you
see
I
didn't
actually
deploy
this
out
yeah.
So
this
is
this
comes
out.
The
box
of
CLI
build
widgets,
sorry
see
I,
like
your
CLI
create
widget,
which
is
the
command
you
can
use
with
the
dojo
CLI,
which
is
available
at
dojo.
C
live
from
NPM
in
order
to
create
your
own
widget
library
and
start
building
out
your
your
widgets
I
hope
we
see
some.
C
C
A
B
B
C
B
Third
eye
that
makes
sense:
let's
get
this
invite,
so
if
you
I
mean
if
you
want
to
chat
or
have
any
questions
around
dojo
in
any
way
shape
or
form,
we've
generally
your
online
on
discord.
Please
feel
free
to
kind
of
hop
in
if
you
have
any
kind
of
ideas.
The
dojo
going
forward.
Probably
the
best
repository
to
raise
an
issue
on
would
be
the
main
framework
issue,
and
then
we
can
move
that
around.
However,
we
want,
but,
however,
we
need
and
I
think
that's
I
think
that's
about
it
and.
C
A
B
Like
new
to
dojo,
not
new
to
dojo,
want
to
kind
of
learn
or
or
have
me
talk
in
to
talk
about,
for
you
know
an
hour
or
so
well
we're
interested
in
hearing
what
people
think
you
know
people
need
they
want.
You
know
what
they
you
know,
what
the
ones
who
kind
of
find
out
keep
an
eye
out
for
we
new
blogs,
we're
gonna
start.
There's
a
few
blocks.
Could
we're
gonna
start
publishing?
One
of
them
is
actually
about
resources
as
well,
which
is
pretty
cool,
yeah
and.
A
I
mean
I
think
we
didn't
touch
on
it
much
at
all,
but
the
whole
build
time,
rendering
thing's
pretty
cool.
We've
actually
done
workshops
before
almost
exclusively
on
like
how
to
build
a
static
site
with
dojo.
If
you
and
again,
if
you
look
at
the
dojo
website
itself,
it's
built
from
a
bunch
of
markdown
files
and
resources,
dojo,
and
you
know
the
dojo
build
time,
rendering
and
dojo
blocks
and
other
features
and
fever.
A
B
Yeah
for
sure
I
mean
I
didn't
touch
the
earlier
and
I
won't
talk
too
long
again,
but
de
jure
IO
is
built
with
dojo.
So
you
get
like
you,
get
the
nice
kind
of
components
or
widget
kind
of
widgets
from
dojo
to
be
able
to
build
your
your
site
in
and
build
time
rendering
and
some
dojo
blocks
that
I'm,
hoping
to
kind
of
maybe
write
blog
on
at
some
point.
B
If
I
ever
get
around
to
it
will
provide
you
a
kind
of
a
static
site
generation
experience
without
like
a
huge
amount
of
configuration,
you
fundamentally
kind
of
work,
work
with
widget
work
with
widgets
still
and
middleware
for
for
actually
producing
and
creating
the
content.
So
yeah
I,
just
double-check
the
questions
and
then
I
guess
we
can
call
it
a
day
it
21:43
yeah.