►
From YouTube: ASP.NET Core Series: PWA's with Blazor
Description
Progressive Web Applications (PWA) use modern browser APIs and capabilities to behave like a desktop app. Since Blazor WebAssembly is a standards-based client-side web app platform, developers have the ability to leverage these browser APIs and create PWAs using .NET.
In this episode, Jeremy is joined by Dan Roth to discuss the built in support for building PWAs with Blazor and show us a few demos of how get started.
[01:44] - What are Progressive Web Apps?
[02:48] - Getting prepared to make your app installable
[05:05] - (Demo) Creating a PWA with Blazor
[07:38] - Exploring the manifest and service worker
[09:30] - Supporting office scenarios
[14:00] - Synchronizing offline updates
[19:22] - Push notifications with PWAs
[24:46] - (Demo) Setting up notifications in code
Get started with Blazor
https://docs.microsoft.com/aspnet/core/blazor/?view=aspnetcore-3.1&WT.mc_id=ondotnet-c9-cephilli
Build Progressive Web Applications with ASP.NET Core Blazor WebAssembly
https://docs.microsoft.com/en-us/aspnet/core/blazor/progressive-web-app?view=aspnetcore-3.1&WT.mc_id=ondotnet-c9-cephilli
Call JavaScript functions from .NET methods in ASP.NET Core Blazor
https://docs.microsoft.com/en-us/aspnet/core/blazor/call-javascript-from-dotnet?view=aspnetcore-3.1&WT.mc_id=ondotnet-c9-cephilli
Get your questions answered on the Microsoft Q&A for .NET - http://aka.ms/dotnet-qa
Learn .NET with free self-guided learning from Microsoft Learn: http://aka.ms/learndotnet
#blazor #PWA #WebApps #AspNetCore #Dotnet
A
A
Hello
and
welcome
to
another
episode
of
on.net,
I'm
your
host
jeremy,
likness
and
today
we're
talking
about
two
exciting
web
topics,
at
least
for
me.
First
is
blazer.
Second,
is
progressive
web
applications,
it's
the
cool
new
thing.
Well,
it's
not
that
new,
but
it's
a
great
feature
and
we're
gonna
dive
in.
I
have
with
me
dan
roth
dan
welcome
hi
everyone.
Thank
you.
B
A
So
blazer
is
something
that
has
been
around
for
a
while.
I
know
when
it
was
first
announced.
I
got
a
little
bit
excited
and
then
I
dug
into
it
and
started
building
a
project
and
got
very
excited,
but
it
allows
us
to
build
single
page
apps
with
c
sharp
and
one
of
the
things
that
people
love
about
single
page
apps
is
the
ability
to
do
a
progressive
web
application.
Can
you
explain
what
a
pwa
is
and
why
anyone
would
even
want
to
have
one.
B
Yeah
sure
I
can
I
could
do
that.
I
have
a
slide
or
two
actually
to
help
out
with
that.
Why
don't
we
go
to
the
slide
real,
quick
there?
It
is
so
just
a
quick
overview
of
what
p
progressive
web
apps.
Are
I
mean
progressive
web
apps
or
pwas
are
just
normal
web
apps,
but
they
leverage
a
few
additional
modern
web
standards
to
give
the
app
a
more
native
app
like
feel.
B
For
example,
the
app
can
be
installed
on
your
platform
of
choice
so
that
if
you're
using
like
a
windows
machine,
you
can
launch
the
app
from
your
start
menu
and
give
it
an
icon
and
give
it
a
sort
of
a
native
chrome
or
shell
around
the
application.
So
it
feels
like
a
native
app
if
you're
on
a
phone,
you
can
launch
it
from
your
your
your
home
screen
like
pin
it
to
your
to
your
home
screen.
B
B
A
So
I've
worked
with
pwas.
I
have
a
blog
that
I
turned
into
a
pwa
and
to
do
that,
I
worked
with
those
open
web
standards
and
had
to
create
a
service
worker
with
javascript,
and
there
were
about
five
million
examples
on
the
web
and
trying
to
figure
out
what
things
actually
did.
It
took
a
lot
of
effort.
I
finally
got
it
working,
but
it
was
a
bit
of
work
to
get
there.
How
does
that
experience
work
with
blazer.
B
Well,
we
try
to
make
it
easy
for
you
in
blazer
to
get
you
set
up
as
a
as
a
pwa.
There
are
a
few
things
you
need
to
do
with
a
blazer
web
application
to
turn
it
into
a
pwa.
Actually,
if
I
could
go
back
to
the
slides,
real,
quick
I'll
go
over
a
couple
of
those
things
and
how
we
help
you
with
that
yeah,
okay,
so,
first
of
all
to
make
the
app
installable,
you
really
need
three
things
in
the
application:
you're.
B
First
of
all,
going
to
need
a
web
manifest,
which
is
just
a
json
file
that
describes
the
app
it
adds
some
metadata
to
the
app.
What
its
name
is,
how
it
should
look
when
it's
running
like,
should
it
be
full
screen?
Should
it
be
in
its
own
window?
What
color
do
you
want
on
the
chrome?
What
icons
do
you
want
to
use
when
it's
pinned
to
your
start
screen
or
to
your
phone's
home
screen?
A
B
Lots
of
ways
to
customize
this
experience,
you
can
do
fancy
things
like
have
an
in-app
installation
experience,
but
those
are
the
the
basics.
If
you
haven't
heard
of
service
workers
before,
if
you're
not
familiar
with
what
those
are.
A
service
worker
is
just
a
chunk
of
javascript.
It's
a
script
that
the
browser
downloads
with
your
app
and
your
app
registers,
and
it
runs
in
the
background
separate
from
your
app
and
service
workers,
can
do
a
bunch
of
things,
but
in
pwas
one
of
the
key
pieces
of
functionality
they
provide
is
they
can.
B
They
can
act
sort
of
as,
like
a
network
proxy,
allowing
you
to
control
how
requests
are
handled.
For
example,
you
can
intercept
requests
and
instead
of
going
to
the
server
you
can
serve
the
you
can
provide
the
requested
file
from
a
cache
and
that
can
enable
things
like
offline
support
to
use
service
workers.
You
do
need
to
run
under
https,
fortunately,
asp.net
core
and
blazer
will
handle
that
for
you
and
they
get
registered
on
on
page
load.
So
I'll
show
you
real
quick.
B
What
that
looks
like
in
blazer
by
the
way,
if
you
haven't
gotten
started
with
blazer
yet
go
to
blazer.net,
that's
the
the
magic
url
and
just
click
on
the
get
started,
button
install
the.netcore
sdk
and
you
should
be
able
to
get
up
and
running
no
problem.
I've
already
done
all
that,
so
I'm
going
to
go
ahead
and
create
a
new
blazer
app,
I'm
just
in
visual
studio
2019.
Let's
click!
B
Next,
I'm
going
to
call
this
blazer
pwa
seems
like
a
good
name
and
then
for
of
these
options,
I'm
going
to
select
blazer
webassembly
app
for
my
pwa,
that's
the
one
that
has
this
additional
pwa
option
down
at
the
bottom,
which
I've
already
checked
previously.
So
it's
checked
for
me.
I'm
also
going
to
check
this
asp.net
core
hosted
option.
B
Build
a
pwa,
but
it's
convenient
for
some
testing
that
I'm
going
to
want
to
do:
blazer
lights
up
certain
pwa
related
behaviors.
Only
when
the
app
is
published
it's
a
little
easier
to
run
the
published
app
if
it's
asp.net
core
hosted
locally
on
my
machine.
Alternatively,
you
could
publish
it
some
way
like
somewhere,
like
to
an
azure
static
web
app
and
just
run
it
there.
So
let's
go
ahead
and
create
that
and
we'll
see
what
we
get
for
our
pwa.
B
So
we
have
our
standard
three
projects
in
our
solution.
We've
got
our
backend
asp.net
core
server
project,
the
blazer
webassembly
client
project
and
then
that
shared
class
library
I'm
going
to
go
ahead
and
run
this
locally
on
my
machine.
So
we
can
see
the
application
and
see
what
did
and
checking
the
pwa
checkbox
do
for
me.
Well,
if
we
look
at
this
app,
it
looks
pretty
standard
standard,
blazer
application.
We've
got
our
lovely
purple
gradients.
Let
me
resize
this
a
little
bit.
We've
got
the
counter.
B
We've
got
the
fetch
data
page,
all
that's
working,
no
javascript
required.
The
thing
that's
different
is
that
edge
is
detecting
up
here,
that
this
app
is
installable
got
this
little
plus
sign,
and
I
can
say
I
would
like
to
install
this
blazer
webassembly
app
on
my
machine
and
now
I
can
close
the
browser
and
it
looks
like
a
native
application.
It's
got
like
a
nice,
pretty
shell
that
matches
the
color
of
my
application.
B
All
the
same
functionality
still
works.
If
I
go
to
my
start
menu,
we
can
see
that
this
app
now
shows
up
in
my
start
menu.
I
can
launch
it
from
there.
Then
I've
got
two
instances,
so
it
looks
and
feels
more
like
a
native
app,
I
was
able
to
install
it
on
my
machine.
How
did
that
happen
like
what
what
made
that?
So,
if
we
go
look
at
the
blazer
webassembly
project,
there
are
a
couple
of
additional
files
that
we
added
to
this
project
for
you
by
checking
that
pwa
option.
B
The
first
is
a
web
manifest
this
manifest.json
file
and
you
can
see
it's
just
a
just
a
chunk
of
json.
It's
has
the
name
of
the
app.
How
do
we
want
it
to
be
displayed
like?
Should
it
have
a
standalone
window,
or
should
it
be
full
screen,
some
colors,
that
we
want
to
use
for
the
chrome
and
then
icons
that
we
want
to
use
when
the
app
is
is
pinned
or
showing
up
in
its
own
chrome?
So
that's
the
first
thing.
B
B
This
service
worker
does
very
little
so
that
you
don't
have
any
caching
issues,
while
you're
trying
to
iterate
on
your
app
during
development,
but
when
you
publish
it
that
service
worker
will
be
swapped
out
for
this
one,
we
just
got
a
little
bit
more
going
on.
This
is
one
of
those
recipes
jeremy
that
you
were
talking
about.
This
service
worker
is
handling
caching
of
the
app
assets
and
clearing
out
you
know
old
cached
asset
assets
so
that
this
app
can
run
offline
and
we'll
look
at
offline
scenarios
in
just
a
second.
B
These
files
get
wired
up
into
the
app
in
the
index.html
file.
So
here's
where
the
web
manifest
file
is
linked
in
the
head
of
the
of
the
html
page
and
then
down
below
you
can
see
the
service
worker
is
being
registered
in
the
script
tag.
There's
a
little
bit
of
ms
build
magic
as
well
to
do
that
swapping
of
the
service
workers
when
the
app
is
published
so
by
default,
we're
going
to
use
serviceworker.js,
but
when
we
publish
we'll
use
that
that
published
js
file.
B
B
There
are
various
strategies
for
the
caching
behavior
that
you
can
use
in
blazer.
We
give
you
a
service
worker
that
implements
a
cash
first
strategy,
so
it
will
always
try
to
go
to
the
cash
first.
If
it's
there,
otherwise
it
will,
it
will
go
online.
You
could
try
to
do
other
fancier
things
like
go
online.
B
If
it
looks
like
you
have
a
network
connection,
and
then
you
only
use
the
cache
when
you're
offline,
trying
to
detect
whether
you're
offline
or
not,
can
be
pretty
tricky
in
a
browser
like
maybe
it
looks
like
you're
online,
but
the
network
connection
you
have
is
is
flaky
or
slow,
or
something
like
that,
so
a
cache
for
strategy
tends
to
be
the
the
simplest
way
to
go.
So
that's
what
we
set
you
up
with.
B
That
only
will
handle
the
the
the
implementation
of
the
app
like
the
app
logic
for
your
data
you're
going
to
need
to
handle
caching,
the
data
yourself
using
browser
features
like
local
storage
or
indexeddb,
and
then
implement
some
sort
of
synchronization
strategy.
Once
the
app
goes
goes
back
online.
B
Now,
I'm
not
going
to
lie
to
you
doing
offline
support
in
a
pwa.
There
are
some
some
gotchas
and
some
some
tricky
things
about
it.
We
have
some
fairly
extensive
documentation
in
the
blazer
docs
about
all
of
the
concerns
related
to
implementing
offline
that
you
can
check
out
at
aka.ms
slash
blazeroffline
considerations,
but
we
get
you
most
of
the
way
there.
Let
me
show
you
what
we
have
so
far
so
with
this
app
well,
this
is
a
pwa.
B
B
So
I
can
bring
up
the
browser,
dev
tools
and,
let's
turn
off
the
network.
So
now
this
app
has
no
access
to
the
network
and
we
can
refresh
it
as
if
we're
browsing
to
this
app
for
the
first
time,
and
you
can
see
it
doesn't,
doesn't
work.
So
this
is
this
app
is
not
currently
functioning
offline
and
that's
because
we're
using
that
dev
only
service
worker,
like
the
service
worker,
that
we're
using
right
now
isn't
actually
doing
any
of
the
caching
that
we
need
to
get
offline
to
work
so
to
get.
B
B
A
B
And
yeah:
let's
do
that?
Okay
and
you
can
see
I'm
going
to
install
it
again,
I'm
running
on
a
different
url.
Now
because
I
published
the
application,
so
we
have
to
install
it
again,
let's
go
ahead
and
do
that.
Okay.
So
now
this
is
the
published
version
of
the
app
still
works
as
before
we've
got
our
fetch
data.
Page
we've
got
counter.
B
Let's
now
again
disable
the
network,
so
f12
bring
up
the
browser.
Dev
tools
go
to
offline
and
let's
try
and
refresh-
and
it
works,
that's
nice.
So
the
app
is
now
functional,
even
without
any
network,
and
you
can
see
that
the
service
worker
is
handling
all
the
requests
for
the
those
those
app
assets
so
that
the
app
can
can
still
function.
B
Now.
That
said,
it's
not
completely
functional.
If
I
go
to
the
fetch
data
page,
oh
error
occurred,
you
know
what
happened
there.
Well,
we
can
see
that
those
fetch
requests
to
the
back-end
web
api
that
are,
that
provides
the
weather
forecast
data.
Those
are
those
are
failing:
we're
not
we're
not
able
to
connect
to
a
back-end
web
api.
A
B
We
have
no
network,
and
so
this
is
the
problem
of
handling
offline
data.
In
this
application,
we've
got
the
app
installed
locally,
but
when
the
network's
gone
it
doesn't
have
any
access
to
its
weather
forecast
data.
So
we
would
need
a
solution
for
that,
but
you
can
you
can
take
care
of
things
like
that
in
a
blazer
application.
B
So
it's
got
this
nice
little
3d
rendering
of
the
the
vehicle
and
it's
got
notes
and
all
the
things
that
are
you
know
dented
or
scratched
on
the
vehicle
you
can
put
in
a
you
know
a
mileage
update
like
let's
say
they
did.
You
know
11
miles
and
you
can
and
just
put
what
the
gas
tank
is
at
75
and
it
has
a
lot
of
nice
blazer
like
features
like
if
we
try
to
put
in
something
silly
for
the
mileage.
It's
like.
No,
that's
not
that's,
not
reasonable.
A
B
Realistically
digging
in
there,
so
although
the
blazer
features
are
available
in
this
application,
but
what
I
want
to
show
is
how
this
app
can
function
offline,
including
with
its
with
its
data.
So
if
I
like,
let's
say
I
select
this
wheel
and
I'm
going
to
add
a
note
and
I'm
going
to
say
you
know
that
the
wheel
might
need
to
be
replaced
and
then
we
can
add
a
photo
yeah.
That
wheel
looks
like
like.
B
B
B
Updated
and
there's
the
timestamp,
so
I
just
have
a
little
authentication
issue
there
and
it's
online,
so
it
was
able
to
persist
the
data
to
the
backend
store.
But
what
happens
when
I
go
offline?
So
let
me
bring
up
the
browser,
dev
tools
and
we'll
switch
from
online
to
offline
and
we'll
go
back
to
our
car.
B
Let's
add
another
note
like
let's
say
you
know
this
headlight
is
now
out
not
working,
save
that
and
then,
if
we
try
to
click
save
now
which
will
try
to
go
to
the
server,
then
we
get
that
error
again.
That
could
not
sync
and
we're
getting
all
these
failed.
Fetch
requests
as
it
tries
to
go
to
the
backend
server
to
save
that
data.
So
it
can't
do
that.
B
But
then,
when
the
attendants
say,
that's
it,
they
were
out
at
the
parking
lot
when
this
happened,
so
they
didn't
have
good
network
coverage,
but
then
they
go
back
online.
They
can
click
this
retry
button
and
then
the
data
is
saved,
so
it's
synchronized
back
to
the
server.
So
this
app
has
offline
support
even
for
the
data
like
you'll
notice.
Even
when
I
was
offline,
I
could
query
for
cars.
I
could
look
at
all
their
their
deals,
their
mileage,
all
that
that
data
was
available.
How?
B
B
So
if
we
go
look
in
this
data
folder,
this
app
has
implemented
this
local
vehicle
store
class
and
this
this
class
is
used
for
managing
all
the
data
for
this
application,
and
it's
got
this
synchronized
method
where
it's.
I
will
try.
What
is
this
like,
so
it
will,
in
this
case
it's
using
the
hp
client
to
actually
try
to
go
to
the
server
that'll
that
will
synchronize
all
the
requests
up
down
below
where's
the
indexeddb
stuff
like
if
I
put
async.
B
When
you,
when
you
save
data
using
this
store,
it
will
actually
store
the
data
first
in
the
a
local
store
and
in
xdb,
and
then,
when
you
run
the
synchronized
logic
up
which
we're
looking
at
up
above,
it
will
use
a
normal
hp
client
to
try
and
sync
that
data
back
to
the
server.
So
this
is
using
js
interrupt
and
I
know
with
blazer
we
try
to
tell
you,
don't
have
to
use
js
interrupt,
but
there's
a
little
javascript
interrupt
code
needed
here.
B
Here's
the
javascript
side
of
that
code
and
it's
not
not
too
bad,
like
here's,
the
the
corresponding
javascript
put
method
and
it's
using
the
indexeddb
apis
to
store
that
locally.
So
this
is
the
type
of
stuff
that
you
have
to
do
in
order
to
handle
offline
data,
support
in
your
pwa
and
then
synchronizing
it
to
the
to
the
server.
A
B
In
this
case,
steve
sanderson
wrote
this
app
and
I
think
he
went
ahead
and
did
his
own
indexeddb
javascript
and
drop
code.
But
if
it
were
me,
I
would
totally
just
go
search
on
the
on
nougat
find
an
indexeddb
library,
that's
already
written
for
blazer
and
just
use
that
then
I
can
just
call
these
things
as
if
as
if
they
were
c
sharp.
It's
pretty
nice
now
the
last
thing
to
look
at
with
pwas.
Let
me
bring
up
my
slides
again,
so
that's
offline
execution.
B
B
So
push
notifications
are
are
are
kind
of
interesting
in
the
the
browser,
the
in
the
case
of
blazer.
We
don't.
We
don't
really
do
much
to
set
this
up
for
you,
but
because
blazer
webassembly
apps
are
just
normal
web
apps.
You
can
pretty
easily
add
the
code
to
do
push
notifications
to
your
application
and
I'll
show
you
how
that's
done
the
way
push
notifications
work
is
the
first
thing
you
need
from
from
the
user
is
permission
to
send
them
a
notification
and
that
that
comes
in
the
form
of
a
subscription
like.
B
B
You
then
typically
send
that
those
tokens
to
your
backend,
like
to
your
your
the
server
side
of
your
application,
and
then
each
browser
has
its
own
push
service,
and
these
are
like
you
know,
cloud
services
that
the
that
browsers
use
so
that
they
can
receive
notifications
from
different
applications,
and
so
from
your
back
end,
when
something
happens
that
you
want
to
notify
the
user
about.
You
would
then
send
a
push
request
to
the
corresponding
push
service
for
that
browser
and
which
push
service.
You
use.
B
That's
all
in
the
subscription
information
that
you
got
when
you
got
the
the
user
to
subscribe
to
your
two-year
notification,
so
you
can
figure
all
that
all
out.
So
it's
different
push
services
per
browser,
but
they
all
implement
a
standard
interface.
So
you
can
talk
to
them
all
the
the
same
way
and
then,
when
you
sit
that
when
that
push
request,
if
it's
accepted
the
push
service
will
send
the
push
event
down
to
the
browser
and
you
handle
that
in
your
service
worker.
Okay,
so.
A
B
This
all
up
we're
going
to
need
to
subscribe
the
user
for
notifications,
we're
going
to
need
to
trigger
the
push
notification
from
our
back
end
and
then
handle
the
push
event
in
our
service
worker,
so
that
the
user
can
then
see
the
notification.
So,
let's
see
what
that
looks
like
for
our
last
little
bit
here,
I'm
going
to
bring
up
a
third
app
for
this
part
of
the
demo.
This
is
the
blazing
pizza
app,
which
is
part
of
a
blazer
workshop.
B
If
you
haven't
done
our
blazer
workshop
before
it's
a
lot
of
fun,
just
go
to
akms
blazer
workshop
and
it's
a
github
repo
with
a
full
set
of
labs
that
will
walk
you
through
building
this
pizza
store
app.
I've
got
that
app
just
loaded
here
and
let's
go
ahead
and
get
it
up
and
running
there
we
go
so
we
can
order
some
pizzas-
and
this
is
this-
is
all
british
pizza
in
honor
of
of
of
steve
steve
wrote
this
app
for
the
first
time
and
he's
kind
of
the
forefather
of
blazer?
B
B
B
B
B
Right,
okay,
so
how
is
this
all
working?
How?
How
are
we?
How
do
we
get
that
push
notification
to
happen?
So
let's
go
look
at
the
the
checkout
page.
So
that's
this
page
here!
This
is
the
one
where
we
we're
putting
in
our
delivery
address.
You
can
see,
there's
a
line
of
code
here
for
requesting
a
notification
subscription
and
again
we're
using
a
little
bit
of
javascript
interop
here
you
know
we
do
have
to
sometimes
delve
into
javascript
first
for
some
features
in
blazer,
but
this
is
invoking.
B
This
request
subscription
call
in
this
javascript
file.
Let's
go
find
that
that's
over
here,
yeah
there's
our
pizza,
a
pizza
just
got
delivered
and
notice.
That
was
offline
right,
like
the
app
wasn't
even
running
so
push.
Notifications
can
talk
to
your
service
worker,
even
when
the
app's
not
running
so
here's
the
code
where
we're
actually
requesting
the
subscription
from
the
user
and
then,
if
we
get
it
back,
then
we
get
this.
You
know
set
of
tokens
that
we
can
use
as
proof
that
the
user.
B
To
harass
them
with
nagging
notifications
about
about
stuff,
so
once
we've
got
this
subscription,
then
we
send
it
to
our
backend
server.
So
we
have
this
little
notifications
controller,
where
we
send
the
notification
subscription
information
to
once.
We've
got
it
from
the
user
and
we're
just
storing
that
in
the
the
database
and
then
when
we
have
an
event
that
happens
that
we
want
to
notify
the
user
about.
B
So
here's
our
orders
controller
again
on
the
server
when
the
say
the
users,
the
users
placed
an
order,
and
then,
after
that
we
start
a
little
process
here,
to
send
them
notifications
about
the
status
of
their
order,
and
here
we're
actually
sending
the
two
notifications
that
the
order's
been
dispatched
and
then
that
the
order
was
finally
delivered.
What
does
that
code
look
like?
Well,
this
code
is
actually
now
talking
to
that
push
service
for
the
the
various
browsers
to
tell
the
push
service.
Please
they'll
send
a
notification
to
this
user's
browser.
B
Now,
how
do
you
talk
to
a
push
service?
Well,
you
need
something
that
knows
how
to
speak.
To
that
standardized
interface
that
push
services
implement.
Blazer
doesn't
actually
give
you
any.
First
class
support
for
doing
that,
but
fortunately
the
community
again
has
has
stepped
up.
Let's
go
into
the
nuget
packages
for
the
my
server
app
and
you
can
see
I'm
using
this
web
push
package
implemented
by
this
person
here,
corey
thompson.
Thank
you
for
implementing
this
and
sharing
with
the
world.
B
B
And
now,
if
we
go
back
to
the
client
project
and
look
at
our
service
worker
for
this
app,
you
can
see
that
it's
registering
an
event
listener
for
the
push
event
and
then
actually
firing
the
notification
on
locally
on
the
machine
with
the
icon
that
we
want
to
use
and
the
message
that
we
want
to
display.
So
that's
how
you
can
connect
the
dot
with
push
notifications
yeah.
B
So
that's
the
push
notification.
So
that's
that's
blazer!
Pwas!
It's
pretty
easy
to
get
started
with!
You
can
just
check
the
checkbox
and
you'll
have
a
blazer
webassembly
app,
that
is
a
pwa.
It
supports
offline.
It
can
be
installed.
We
have
wonderful
docs
on
how
to
do
this,
like.
Let
me
point
you
to
one
link
real
quick.
B
If
you
go
to
the
blazer
documentation
and
then
just
scroll
a
little
bit
down
the
toc
you'll
see
this
progressive
web
apps
topic,
and
this
has
lots
of
great
stuff
that
describes
all
the
things
I
showed
you
and
more
for
implementing
your
next
pwa
with
blazer.
You
can
look
at
the
car
checker
code
that
I
showed
today
at
aka.ms,
blazer
car.