►
Description
PnP webcast around the options and story on migrating existing JavaScript-based customizations in SharePoint Online to SharePoint Framework Extensions using then application customizers, list view command sets and/or field customizers. A more detailed description of covered topics from https://dev.office.com/blogs/migration-to-sharepoint-framework-extensions
A
Welcome
to
the
shipment,
Patterson
practices
webcast
and
sister
we're
going
to
talk
about
how
to
my
create
your
existing
JavaScript
customizations
for
in
shipment
online
to
the
SharePoint
favorite
extensions.
My
name
is
Esther
Yvonne
and
I'm,
a
senior
program
manager
from
shape
and
engineering,
and
with
me
today,
responsable
of
the
demo
staff
is
Paul
of
the
LRC
Sao
Paulo.
Will
it
do
the
quick
intros
as
well?
Yes,.
B
A
Okay,
let's
concentrate
on
today's
topic,
so
we
wanted
to
talk
about
the
fact
that
how
do
you?
Actually?
What
does
the
my
creation
of
a
let's
say,
a
classic
and
well
maybe
classic
JavaScript?
Embedding
customization
isn't
the
right
term,
but
javascript
is
link
customization
or
user
customer
interaction
customization.
How
would
you
transform
that
to
work
in
a
SharePoint
framework
and
what
is
the
transformation
process
and
what
are
the
options
and
all
the
time?
A
And
we
cannot
walk
through
and
these
case-by-case
also
in
a
demo,
so
you
will
see
the
the
previous
scenario
and
you'll
see
how
it
has
been
transformed,
but
before
we
actually
go
there,
let's
quickly
have
a
look
on
what
is
the
SharePoint
framework
extension
just
to
recap
this
one,
if
you're
not
familiar
with
in
so
we
have
kind
of
a
three-way
three
different
extension
types,
our
extension
extension
components
or
estimation
types,
application
customizer
is
one
of
these
extensions.
It
gives
you
a
capability
of
executing
code
in
any
page
of
the
site
or
site
collection.
A
Again
slightly
depends.
Where
are
you
registering
this
application
customers
as
what
is
the
scope
of
the
application
customizer,
and
it
also
gives
you
you're
able
to
embed,
for
example,
let's
say
a
sure,
application
insights,
Analytics
to
your
pages
or
you're,
also
able
to
end
with
its
JavaScript
UI
elements
in
the
top
section
of
the
page
or
in
the
bottom
section
of
the
page,
where
you
might
call
them
header
and
footer.
A
Do
internal
decisions
we're
not
calling
them
actually
hit
around
food,
called
him
a
top
and
button
placeholders,
but
you're
able
to
add
your
custom
JavaScript
there
and
that
JavaScript
can
do
whatever
so
you're.
The
classical
scenarios
could
be
something
like
hey:
I
want
to
have
a
custom,
navigation
or
I
want
to
have
a
custom
footer
which
has
personalize
the
information
like
in
the
picture.
Here
you
can
absolutely
make
that
happen
now.
This
could
be
in
an
old
way
of
implementing.
A
This
was
implemented
typically
using
a
user
custom
action
collection
and
embedding
at
Java
Script,
which
was
then
having
a
dependency
on
the
Dom
structure
of
the
page
yeah
application
customized.
That
technically,
is
actually
I
use
a
custom
action,
but
it
takes
advantage
of
slightly
more
sophisticated
implementation
and
will
quickly
have
a
look
on
those
things
in
the
demo
section.
A
When
somebody
clicks
the
menu
item
or
somebody
clicks
the
the
button
in
the
toolbar,
so
you
might
kind
of
compare
this
to
easily
be
or
custom
action
menu
items
in
the
in
the
classic
scenarios
and
kind
of
related
on
that
one.
We
were
just
chatting
this
one
before
we
started
recording.
So
if
you
hadn't
easily
be
many
items
in
the
classic
implementation
which
doesn't
contain
JavaScript,
it
actually
is
immediately
available.
A
Also
in
the
in
the
modern,
modern
experiences
or
I
say
well,
yes
in
the
modern
experiences,
but
if
your
existing
ezb
or
the
the
ribbon
button
has
a
JavaScript
inside
of
it,
those
won't
be
actually
supported
as
such.
So
you
need
to
do
a
transformation
to
the
command
set
to
make
the
JavaScript
execute.
A
The
final
piece
is
to
fill
customizer.
This
could
be
compared
with
the
Chaves
chase
link
such
as
link
in
the
field
level
as
to
overwrite
the
rendering
of
the
field
value
right
now.
The
field
customizer
only
supports
the
rendering
experience,
so
it
doesn't
actually
support
the
editing
experience
that
might
be
something
depending
on
when
you're
watching
the
video
it
might
be
already
coming
out
or
mine
is
something
which
is
coming
out
later,
because
it
is
in
our
roadmap
when
we're
recording
the
video
anything
here.
A
What
does
it
actually
means
how
how
these
things
actually
work
so
how
the
X
station
executes
on
the
pages,
so
when
somebody's
arriving
on
a
page
or
a
user
is
navigating
to
the
list
or
library
or
a
page
or
a
modern
page
as
well.
So
what
actually
gonna
happen
in
here
is
that
the
server
returns
an
application
data.
Those
are
the
list,
data
or
Bates
data.
It
also
returns
to
SharePoint
framework
JavaScript
libraries
and
it
also
returns
for
the
client
so
as
in
the
browser
manifest
for
all
of
the
active
SharePoint
favorite
components.
A
So
what
are
extension
and
webparts,
which
should
be
rendered
as
part
of
this
page
or
HTML
page
which
the
user
is
accessing
and
then,
when
that
happens,
then
the
browser
in
the
Krauser.
We
have
an
application
object
so
to
say
which
is
kind
of
a
controlling
the
rendering
orchestrating
all
four
things
which
is
getting
loaded.
That's
the
one
which
is
responsible
of
checking
the
manifest
of
the
SPF
ESP
F
X
component
and
then
starts
to
loading
the
manifest
the
JavaScript
files
from
the
from
the
location.
Normally,
this
is
a
CDN.
B
A
Not
a
mandatory
thing,
you
can
absolutely
help
your
JavaScript
files
from
a
root
side,
collection
of
your
tenant,
that's
a
suitable
option
as
well
now
and
then,
when
application
has
been
finished,
rendering
and
all
of
the
top
web
parts
and
expectations
are
executed.
So
that's
a
final
step
on
the
page
and
what
then
happens
is
that
those
individual
components
like
to
live
list
view
common
sets.
In
this
case,
you
can
see
that
right
or
a
dark
markers
in
a
tool
bar
and
an
enlistment.
A
You
are
available
for
your
end
users
to
select-
or
it
might
be,
the
header
or
header
section
on
the
top
section
of
a
page
which
is
a
fully
customized,
and
that's
why
the
application
customizers
could
be
remaining.
It
could
be
actually
in
a
footer
as
well
or
it
could
be
the
field
customize
or
what's
responsible
of
rendering
the
fill
value.
So
in
this
case,
there's
a
field.
A
Customize
I
was
rendering
the
map
value
of
the
of
the
location,
so
quite
simple
scenario
in
the
end
and
quite
simple
how
it
actually
works,
but
obviously,
what's
interesting
is
that
how
do
we
now
transform
if
you
have
existing
user
custom
action
based,
customizations
or
chase
link,
customizations
or
ezb
menu
customization?
What's
the
end
user
experience,
first
of
all,
when
you're
flipping
between
the
classic
and
modern
and
also
how
can
those
be
my
credit
and
the
modern
experience?
So
let's
do
a
live
demo.
A
This
one
won't
be
deep,
diving
on
the
exact
technical
steps
and
details
and
everything
else,
but
we
do
have
a
tutorial
articles
available
on
actually
on
all
of
the
samples
which
we
have
also,
but
so
let's
have
a
look
on
the
classic
implementation,
and
also
the
modern
implementation
and
Paolo
is
going
to
show
that
one
in
practice
so
take
it
away.
So,
let's
jump
on
the
demo.
Okay.
B
Thank
you
visa.
So
here
we
are
in
a
classic
Tim
site
in
SharePoint
Online,
and
this
classic
Tim
site
has
been
extended
using
some
of
the
SharePoint
feature
framework
capabilities
like
for
example.
Here
you
can
see
a
user
custom
action
through
which
I
extended
the
pages
of
this
site
in
order
to
have
a
custom
footer
in
every
single
page,
which
will
just
provide
few
useful
links
to
the
end
users
of
my
site
collection.
This
solution
has
been
built
using
a
user
custom
action.
B
We
can
have
exactly
the
same
result
from
an
end-user
experience
perspective
if
we
switch
to
the
modern
experience
in
this
site.
So,
for
example,
if
I
go
to
see
a
modern
library
in
this
site,
you
will
see
that
now,
I
have
the
modern
experience,
but
still
in
the
lower
area
of
my
screen,
a
footer
bar
here
with
almost
the
same
links
and
useful
items,
of
course,
with
the
new
branding
which
is
based
on
the
official
fabric.
So
it
is
nicer,
responsive
and
cooler,
but
still
with
the
same
functionalities
from
an
end
user
perspective.
That's.
A
Before
you
go,
that's
that's
a
really
good
point
as
well,
because
when
you're
doing
this
transformation
from
a
classic
experiences-
and
this
in
this
case
chase
link
sorry
script
source
reference
in
the
user
cast
an
option
to
the
application
customers,
it's
a
create
chance
to
revisit
the
design
and
also
to
revisit
and
the
UI
design
and
the
requirement
of
this
customization.
So
obviously,
customizations
are
not
bad
and
typically
there's
a
business
requirement
and
functional
requirements
by
the
customization
is
there.
But
this
is
a
great
opportunity
to
revisit.
A
Why
does
it
exist
and
can
we
actually
make
it
nicer
better,
more
flexible
for
the
entry
services
well
like
in
this
case
it
looks
much
nicer
in
the
context
of
the
site
because,
yes,
that's
rendered
in
all
of
the
modern
experiences
within
the
site,
so
the
same
Fuller
is
consistent.
So
that's
quite
exactly.
B
B
So,
having
a
look
at
the
first
user,
custom
action
from
a
SharePoint
feature
framework
perspective.
So
whenever
you
want
to
create
such
an
extension
using
the
feature
framework,
you
have
to
create
a
feature
file
feature
element
file
with
a
bunch
of
custom
actions
like,
for
example,
here
I'm
using
the
jQuery
jQuery
CDN
content,
which
will
be
included
with
the
script
link.
Custom
action
in
every
single
page.
B
Every
single
classic
page
of
my
site,
as
well
as
I,
have
a
custom
action
which
will
still
use
the
script,
link,
approach
and
location
to
embed
one
custom
javascript
file
in
every
single
classic
page
to
have
my
footer
rendered
I.
Don't
know
if
we
wanna
dig
into
the
details
of
the
JavaScript
5
by
itself
or
not,
but
basically
I
just
play
with
the
document
object
model
of
the
page
to
embed
the
custom
footer
in
the
document
of
the
model
and.
A
That's
it.
That's
actually
a
good
point
as
well
as
I've
been
pointing
few
things
here.
So
that's
a
script
source
link
which
is
pointing
to
the
JavaScript
file.
So
at
this
point
you're
using
a
JavaScript
which
is
the
SPL
custom
UI,
it
needs
to
know
where
it's
actually
getting
in
check
that
the
functionality
and
in
SharePoint
framework
we
actually
keep
you
two
placeholder,
so
you
can
actually
say
for
SharePoint
framework.
Hey
I
wanna
put
something
on
the
on
the
button
area
of
the
page.
A
Give
me
the
host,
where
I'm
actually
able
to
put
that
and
the
problem
with
the
classic
implementation
with
the
user
custom
action
is
that
whenever
we
in
SharePoint
engineering
we
evolve
the
UI,
your
dumb
structure,
pointers
will
break
and
that
could
universe
case
scenario.
Nothing
will
be
rendered
for
infusers
and
that's
that's
not
an
optimal
situation
but
SharePoint
framework.
We
currently
the
references,
will
work
exactly.
B
In
fact,
if
we
reach
to
the
SharePoint
framework
extension
solution
here,
we
still
have-
and
here
we
are
in
a
SharePoint
framework
solution
here
we
still
have
a
feature
element
file
and
custom
action.
But
right
now
we
are
just
placing
a
custom
component
based
on
a
specific
ID
which
will
identify
uniquely
identify
our
component,
which
will
be
the
custom
application
customizer
into
a
specific
location,
which
is
the
one
for
all
of
the
application
customizer.
B
This
ID
is
declared
in
the
manifest
jason
manifest
file
of
our
extension,
and
here
we
simply
declare
few
information,
including,
of
course,
the
fundamental
ID
of
the
customizer
and
in
the
typescript
file
in
which
we
have
the
real
implementation
of
the
customizer.
We
have
a
typescript
class
which
will
inherit
from
a
base
type
provided
by
the
basic
infrastructure
of
sharpen
framework,
and
we
simply
look
through
a
placeholder
provider.
B
We
simply
look
for
the
bottom
prophet
place,
order
of
the
page
so
that
we
can
embed
our
custom
footer,
which
will
be
a
react
component,
but
could
be
any
JavaScript
element
that
you
like
inside
the
placeholder
within
the
page.
So,
even
if
Microsoft
will
change
a
slightly
change,
the
layout
of
the
modern
pages,
we
will
still
have
the
bottom
placeholder
and
our
content
will
be
still
there.
So
we
will
not
have
any
troubles
in
the
rendering
of
our
custom,
footer
or
custom
elements
in
the
page.
Absolutely.
A
And
maybe
one
more
additional
thing:
the
pin
point
on
this
one
which
we
donated
repeat
on
the
other
extensions,
is
then
the
the
client-side
client
call
side
component
ID
in
the
user
custom
action.
It
looks
like
the
same
like
like
how
we
associated
that
javascript
in
the
older
implementation,
but
there's
a
clear,
big,
big,
big
difference
around
the
covenants
of
that
one
to
be
able
to
use
to
share
on
favorite
stations
and
that
extension
has
to
be
deployed
in
the
app
catalog,
and
this
is
something
what
all
of
our
customers
have
been
asking.
A
We
want
to
have
more
centralized
control
if
that
an
issue,
if
it's
not
a
we
it
dependent
on
who
has
access
on
the
App,
Catalog
and
app
catalog
people
can
then
control
what's
available
and
what
can
be
associated
to
the
side.
So
that's
a
really
one
additional,
let's
say
difference
between
the
classic
customizations
and
the
modern
customization.
So
there
is
the
governance
controller,
if
prefer
to
do
so.
B
Absolutely
absolutely
so
now,
let
me
go
back
to
my
team
side
and
let
me
show
you
another
example.
So
now
let
me
switch
to
the
classic
experience,
even
when
I'm
browsing
through
the
documents
or
the
items
in
lists,
and
here
we
have
a
list
with
the
classic
UI
in
which
I
customize,
the
rendering
of
a
field
of
a
color
field.
It's
just
an
easy
example.
So
let
me
show
you
in
this
page
how
the
customization
works.
B
So
let
me
edit
this
page
and
let
me
show
you
that
in
the
settings
of
these
list
view
web
part
under
the
miscellaneous
area.
Here
we
have
a
J's
link
attribute
through
which
we
define
that
we
want
to
use
a
custom
javascript
file.
Whenever
we
will
render
this
list
view
and,
of
course,
inside
the
JavaScript
file,
we
will
have
a
bunch
of
a
code
which
will
simply
provide
a
custom
rendering
for
the
color
field,
with
a
colored
box,
with
the
same
color
that
we
are
using
for
the
filled
value
of
the
current
item.
B
What
I
mean
is
that,
of
course,
if
I
edit,
these
lists,
every
single
item
will
have
a
color
and
I.
Can
play
with
these
nice
UI
and
see
the
exactly
the
same
color
that
I
selected
in
the
field
property
of
my
item,
so
this
behavior
can
be
nice.
Of
course
you
can
create
whatever
custom
field
you
like
using
the
GS
link
approach,
but
again
in
one
more
time
it
uses
a
JavaScript
file,
somehow
embedded
in
the
page,
without
governor's
and
control
from
the
admins
and,
moreover,
if
I
switch
back
to
the
modern
experience.
B
A
And
on
that
one,
maybe
my
summary
might
be,
but
why
can't
you
an
answer
is
the
whole
rendering
logic
is
so
different
with
the
modern
UI
and
more
optimized
and
responsive
and
and
many
other
things
that
the
the
classic
J's
link
way
of
doing
stuff.
It
just
isn't
supported,
and
it
will
never
be
supported
in
here
exactly.
B
And
on
the
other
side,
don't
panic
because
we
have
another
solution,
the
field
customizers.
So
let
me
show
you
yet
another
list
which
now
has
been
customized
from
a
rendering
perspective,
using
using
the
SharePoint
framework,
extensions
and
precisely
a
SharePoint,
a
framework
of
Phil,
the
customizer
right
now,
I
have
exactly
the
same
behavior
as
before,
but
now
with
in
a
modern
list
rendered
in
the
modern
UI
of
a
short
point.
So
exactly
the
same
behavior
as
before.
Right
now,
we
do
have
this
custom
rendering
in
the
ListView.
B
Only
so
we
still
don't
have
the
capability
to
have
a
custom
rendering
in
the
edit
or
in
the
add
new
forms.
But
as
I
said
a
few
minutes
ago,
it
will
come
it's
not
his
way.
Let
me
say,
and
from
a
different
perspective,
one
more
time
you
saw
how
you
can
use
the
GS
link
in
the
classic
mode.
Let
me
show
you
how
you
can
use
the
field
customizers
in
the
SharePoint
framework
approach.
B
So
let
me
go
here,
and
here
we
are
in
another
SharePoint
frame
or
solution
in
which
we
have
a
field
customizer,
which
still
has
a
manifest.json
file
with
a
unique
ID,
still
has
a
feature
element
from
the
SharePoint
feature
framework.
But
now
the
feature
element
will
declare
a
custom
field
which
will
have
a
client-side
component,
ID
declared
for
the
custom
rendering
of
this
field
and
the
custom,
rendering
will
be
realized
will
be
implemented
inside
a
type.
B
A
class
in
typescript
in
our
SharePoint
framework
solution,
and
this
class
will
inherit
from
a
base
field
customizer
type
and
in
the
on
render
cell
method
overriding
will
simply
fine.
What
will
be
the
behavior
of
our
custom
field
and
what
is
really
powerful
here
is
that
here
we
can
use
fully
typed
code
using
typescript
benefit
with
the
benefit
of
the
fully
typed
approach
of
typescript.
So
we
can
access
the
entire
model
of
rendering
of
our
field
just
using
an
object-oriented
approach,
and
we
can
go
through
all
of
the
elements
that
render
our
item.
B
We
can
apply
custom
styles
to
them
with
fully
typed
approach
here
as
well
of
sorry,
so
we
have
in
full
intelligence
in
the
code
editor,
for
example,
even
if
here
I'm
referencing
styles,
that
are
in
the
in
the
a
CSS
file
of
my
solution.
So
here
I
have
a
style
file
which
I
can
define
using
the
well
known
as
CSS
syntax,
but
in
the
code,
I
will
have
a
fully
type
approach
to
reference,
those
Styles.
So
from
a
coding
perspective,
it's
a
better
experience
because
I'm
fully
supported
by
the
environment.
A
B
Let
me
show
you
one
last
example:
the
last
example
will
be
the
ACB
menu
items.
Most
of
you
must
likely
created
in
their
solutions,
custom
extension
for
ACB
menu
and
for
the
ribbon
bar
in
the
classic
experience.
So
let
me
go
back
one
more
time
to
the
classic
experience
and
let
me
go
to
the
document
library
of
the
shared
document
in
this
site
here.
B
I
have
a
few
sample
document
and
I
can
click
on
the
ACB
button
and
I
can
just
activate
any
of
the
custom
actions
that
I
can
have
in
the
ACB
menu
like,
for
example,
this
one,
which
is
just
for
the
sake
of
making
an
example
in
ACB
item
which
will
open
a
custom
page
which
in
reality
does
not
exist
in
this
scenario,
but,
as
you
will
see,
it
will
have
in
the
query
string
the
ID
and
the
list.
Id
of
my
item,
of
course
you
could
have
a
custom
page.
B
They
are
doing
something
around
the
item
which
has
been
selected
by
the
user.
So
now
this
solution
is
an
ACP
customization
which,
as
long
as
it
does
not
use,
any
JavaScript
code
can
be
migrated
or
better
can
be
still
used
in
the
modern
lists
and
libraries.
But
if
this
a
seaman
would
have
any
custom
JavaScript
code
inside
of
it,
of
course,
because
of
the
JavaScript
embedding
it
wouldn't
be
available
in
the
modern
experience
in
the
modern
UI
of
lists
and
libraries.
B
So
again,
and
one
more
time
we
can
have
the
same
behavior
as
before,
so
a
custom
page,
which
does
not
does
not
exist
in
reality.
With
the
idea
of
the
item
and
the
idea
of
the
list,
but
we
can
even
do
more
because
in
the
SharePoint
framework
extensions
we
can
use
typescript
and
JavaScript,
we
can
use
the
office
way
fabric
and
we
can
create
nice
UI
elements.
So
let
me
show
you
one
more
example
and
then
I
will
go
back
to
the
real
implementation
of
that
extension.
B
So
here
we
are
in
another
side,
which
is
modern
side
in
which
I
have
a
document
library
and
if
I
select
a
document
in
this
document,
library
I
have
this
disgust
Now
button,
which
I
can
click.
This
one
is
a
common
set
built
using
the
SharePoint
framework
extensions,
as
you
can
see
now,
I
have
a
nice
dialog
window
which
is
built
using
the
dialog
framework
of
SharePoint
framework,
as
well
as
the
office
UI
fabric
components.
B
I
can
select
field
values
using
a
very
nice
and
the
friendly
UI
and
I
can
interact
not
only
with
SharePoint
Online
by
itself,
but
to
be
fair
in
this
example,
I'm
going
to
create
a
meeting
an
event
in
a
calendar
which
is
in
an
office
to
this
five
group
so
because
I'm
in
SharePoint
framework
and
because
I'm
in
the
modern
development
experience
I
can
benefit
of
the
full
micrograph
offering
and
they
can
interact
with
the
full
ecosystem
of
services
provided
by
office.
Trees
differ
even
if
I'm,
in
the
modern
experience
or
let
me
say
thanks.
B
Ok,
so
let
me
switch
back
to
the
previous
daemon.
Let
me
show
you
or
let
me
compare
what
was
the
old
classic
mode
of
creating
an
ACP
menu
which
was
based
on
a
custom
action
and
using
the
SharePoint
feature
framework,
and
here
again
we
have
a
custom
action.
We
have
a
registration
type
and
a
register,
and
we
have
a
you
our
election,
which
will
be
the
behavior
that
we
we
will
apply
to
our
custom
action,
the
contrary.
B
If
we
want
to
create
a
common
set,
it
will
be,
it
will
be
again
in
one
more
time
a
type
script
file
in
which
we
will
have
a
class
inherited
by
inheriting
by
the
base
list
view
common
set
type
provided
by
the
SharePoint
framework,
basic
infrastructure
and
in
the
unexecuted
method
we
will
get
a
event
argument
which
will
simply
allow
us
to
identify
what
is
the
event.
What
is
the
common
that
we
are
going
to
execute,
and
this
will
be?
B
This
will
be
based
on
a
list
of
comments
of
items
that
we
can
declare
in
the
manifest
of
our
common
set.
So,
for
example,
here
I
have
an
item
called
shawl.
It
is
with
a
specific
title
and
which
will
be
of
type
common,
which
is
the
one
we
have
right
now,
and
so,
whenever
there
will
be
the
execution
of
an
event
which
will
be
of
type
show
details
here,
I
can
just
get
some
information
using
the
selected
rows
array
of
rows,
which
I
have
in
the
event
to
get.
B
For
example,
the
idea
of
the
currently
selected
item
or
the
list
ID
or
whatever
I
say,
need
to
implant.
My
custom
business
logic
so
really
powerful,
much
more
powerful
than
just
a
bunch
of
JavaScript,
embedded
in
the
user
custom
action
that
we
had
in
the
classic
mode
and
with
the
full
set
of
capabilities
like
the
SharePoint
framework,
dialog
framework
and
the
official
fabric
to
create
a
nice
UI
and.
A
I
would
say
that
for
all
of
these
things,
it's
it's
not
just
power,
but
there's
also
the
reliability
and
the
stable
implementation,
so
the
SharePoint
framework
isn't
dependent
on
a
Dom
structure,
modifications
or
those
things.
It's
it's
much
more
reliable
platform
and
that's
what
we
want
to
also
well
that
that
is
one
of
the
key
design
objectives
of
SharePoint
framework
increase.
The
stable
is
a
provide,
a
capability
of
enabling
still
extending
SharePoint
Online,
but
in
a
more
reliable
way,
and
that's
that's
been
a
design
decision
from
day.
B
Exactly
precisely,
in
fact,
that's
what
I'm
going
to
show
you
now
on
the
docks
that
Mexican
website
under
the
SharePoint
framework
section
in
the
extensions
concept
migrating
existing
customizations,
you
will
find
three
different
tutorials
through
which
you
can
go
through
all
of
the
steps
needed
to
migrate,
a
classic
development
solution
like
a
CB
menu
user
custom
action,
J's
link
using
the
new
approach.
The
new
modern
approach
through
the
SharePoint
framework
extensions
so
feel
free
to
use
those
tutorials
as
referenced,
and
you
will
be
able
to
recreate
all
of
the
samples
that
I
just
showed
you.
A
A
Good
work,
through
of
things
and
what's
actually
really
cool
like
Paula,
showed
on
the
demo
as
well.
It's
really
important
to
realize
that
it
doesn't
matter,
are
using
a
classic
team
side
or
are
using
a
croup
side,
and
if
you
fall
between
the
modern
experiences
and
classic
experiences,
you
are
at
the
same
time
flipping
between
SharePoint
framework,
extensions
being
supported
or
the
classic
customization
being
supported.
A
So
if
you
have
a
scenario
where
you
need
to
support
both,
let's
say
experiences,
it
might
be
that
you
need
to
implement
and
use
a
classic
user
custom
action
or
a
chance
link
and
then
also
share
one
framework
extension.
So-
and
this
is
something
to
take
into
consideration
when
the
the
solutions
are
being
designed.
B
That's
why
I,
based
on
what
you
just
said,
that's
why
we
often
say
that
the
modern
development
and
the
SharePoint
framework
are
not
a
replacement
for
the
classic
model.
They
can
work
together,
depending
on
your
context,
so
that
the
only
addendum
I
want
to
add
and
want
to
say.
Thank
you
for
watching
this
video,
absolutely.
A
So,
thank
you
Paulo
for
great
demo
and
thank
you
everybody
for
watching
the
video
and
keep
on
add
the
feedback
coming.
If
there's
something
missing
on
the
shape
and
framework
extensions,
I
don't
have
on
premiere,
please
let
us
know
using
the
key
top
and
use
of
all
channels,
but
thank
you
for
watching
and
we'll
come
up
with
a
new
webcast
sooner
or
later.
Thank
you.