►
From YouTube: How To: Submit a Pull Request to PnPjs
Description
Shows how to go from idea to code change to pull request for the PnPjs library.
A
Hello
and
welcome
to
a
short
video
on
how
to
do
a
pull
request
for
peon
PJs,
though
this
would
very
much
apply
across
any
of
the
repositories
related
to
the
patterns
and
practices
program,
these
same
kind
of
steps,
but
so
to
get
started.
We're
just
going
to
come
up
with
an
idea
and
one
of
the
great
ways
to
come
up
with
an
idea
is
to
check
out
the
issues
list.
So
here's
the
issues
list
for
P
and
PJs
and
we're
just
gonna
go
down
real,
quick
and
we're
gonna
pick
an
issue.
A
I've
already
pre
picked
out
this
issue
export
SP
batch,
but
you
could
come
up
with
your
own
ideas,
of
course,
find
an
issue
to
help
out
with
in
the
list.
However,
you
might
want
to
go
about
that
and
now,
in
my
case,
I'm
gonna
go
ahead
and
assign
this
to
myself,
because
I
have
those
rights
in
this
repository.
But
if
you
can't
do
that,
you
can
always
come
in
here
and
leave
a
comment
and
say
something
like
you
know,
I'm
going
to
work
on
this,
and
that
will
help
us.
A
So
we
don't
duplicate
our
efforts
or
step
on
anybody's
toes
and
the
other
thing
I'm
going
to
do
which,
which
you
wouldn't
have
to
do,
but
I'm
going
to
change
the
label
from
investigate
to
in
progress.
Let
me
find
it
there
and
so
that's
in
progress
now
and
that
kind
of
lets
people
know
this
is
being
worked
on
and
lets
us
know
to
not
come
and
also
work
on
it
or
other
folks.
A
So
we
don't
get
the
the
kind
of
cross
work
so,
but
looking
at
this
issue,
you
know
we
always
like
to
look
at
the
feedback
we
get
from
folks.
So
we'll
take
a
look
and
we'll
say:
okay,
so
what's
this
person
want
to
do
they
want
to
return
the
SP
batch
object
and
they
need
those
Taipings
and
from
from
this
issue,
I
guess
we're
not
exporting
that
class.
A
However,
you
want
to
call
it
and
I've
gotten
the
latest,
but
one
of
the
things
you
can
do
before
you
start
is
always
pull
from
the
upstream
to
make
sure
you've
got
all
the
latest
changes,
and
this
will
one
make
sure
you
have
all
the
latest
changes,
but
two.
It
can
make
it
a
lot
easier
when
you
go
to
merge
if
your
fork
might
be
out
of
date
or
you're
working
on
a
certain
branch,
that's
out
of
date,
and
so
the
other
thing
we
want
to
do
is
we
want
to
look
at.
A
How
you
want
to
approach
that
is
really
up
to
you
and
so
we'll
come
in
here
and
the
first
thing,
if
we're
gonna
make
a
change
to
the
code
we
want
to
do
is
find
where
we
want
to
make
this
change
so
I'm,
just
gonna,
search
for
SP,
batch
and
I
found
a
ton
of
things,
but
we
can
ignore
some
of
these.
That's
an
image
so
we're
exporting
this
class
out
of
batch.
That's
good
to
see
so.
A
Document
you'll
see
I've
got
a
little
red
squiggly.
Here
you
could
ensure
the
fixes
fix
the
missing
trailing
comma.
There
you
go
all
set,
so
we've
added
our
export
for
SP
batch
a
nice
easy
change,
but
we
want
to
kind
of
test
this
and
one
of
the
easiest
ways
to
test
your
changes,
and
this
is
for
big
changes.
A
Small
changes,
one
of
the
things
we've
done
is
we've
set
up
this
debug
folder
and
if
you
haven't
looked
at
this
before,
there's
two
sub
folders
here,
one
for
launch
and
one
for
serve
and
the
launch
folder
I
have
a
bunch
of
extra
files
that
I've
used,
but
you'll
see
a
main
file
and
an
SP
file
and
a
graph
file.
Those
would
be
part
of
the
actual
package,
and
then
these
are
ones
I've
set
up.
Just
for
my
local
testing
different
things
I've
been
working
on.
A
This
helps
me:
do
testing
of
issues
and
stuff
quickly
or
or
keep
some
sample
code
around,
for
example,
client,
side
pages,
but
I
have
this
any
module
and
it
has
just
a
bunch
of
junk
code
in
it.
But
what
I
want
to
do
just
to
test?
This
is
first
I'm
gonna
go
to
main
and
I'm
gonna
up
the
update
this
to
pull
in
my
any
module
here
as
the
code.
A
That's
going
to
be
run
for
main
and
I
can
come
in
here,
and
so
here
we
actually
are
already
importing
a
few
things
from
the
SPE
project,
so
I'm
just
gonna
type
here
and
we
get
SP
batch
is
being
exported
now,
so
we
see
that
change
has
actually
come
through,
so
we
could
essentially
proved
now
that
our
change
worked.
In
this
case
we
were
just
adding
an
export,
so
that's
pretty
easy
to
see,
but
we
could
also
come
down
here.
Then
we
can
use
these
things
than
in
code.
A
So
we
could
say
our
batch
is
gonna,
be
an
SP
batch
and
we're
gonna
get
that
from
SP
web
create
batch,
and
that
will
give
us
our
typing
on.
This
object
is
now
typed
as
an
SP,
and
we
could
see
that
is
importing
correctly
from
the
SP
library.
So
that's
a
quick
and
we
could
do
our
batch
operations,
so
we
can
execute
these
things
and
we
can
add
to
them.
A
Although
we
don't
generally
operate
on
the
batch
object
directly,
we
would
do
things
like
SP
web
in
batch,
give
it
the
batch
and
then
get
those
values
right.
So
we
could
do
something
like
this
and
that
works
great,
but
so
we've
we've
proven
that
we
are
changed
works,
and
so
we
want
to
now
get
that
pushed
up
and
make
an
actual
pull
request.
So
this
is
I
think
the
part
folks
might
have
a
little
more
confusion
around
or
be
a
little
more
unsure.
I
know
I'll
admit
when
I
was
starting
out
with
git.
A
It's
very
confusing
it's
a
little
a
little
scary
in
a
way
right,
because
it's
a
new
system
you've
got
to
learn
it
and
it
seems
like
when
you
do
stuff.
It's
very
final
and
it
seems
very
easy
to
break
things.
But
with
a
few
simple
steps,
you
can
create
a
pull
request
and
it's
really
not
that
hard,
and
it
would
encourage
all
of
you
to
give
it
a
try,
if
not
for
P
and
pjs.
A
Please
do
for
us,
but
but
for
other
libraries
you
might
use
other
projects
you're
involved
in
the
folks
that
are
maintaining
them.
Absolutely
appreciate
your
assistance
and
your
help.
If
you
have
ideas
for
making
things
better,
so
one
of
the
things
I'm
in
Visual
Studio
code-
that's
nice
is
they
have
this
source
control,
which
is
just
shown
by
this
little
branchy
icon
over
here,
and
you
can
actually
click
the
files
and
review
your
changes.
A
You
can
actually
write
in
here
discard
some
changes,
so
I
never
want
to
check
in
my
changes
to
main
that's
kind
of
a
shared
example
file,
so
I'm
just
going
to
discard
those,
but
then
I
can
look
at
here's
our
package
here.
We've
got
our
export
of
the
XSP
batch.
We
can
see
that
was
added,
so
the
left
is
the
original.
The
right
is
our
changed
file
or
our
local
copy
and
the
working
tree,
and
so
that's
really
great
and
now
I'm
gonna
switch
over
to
the
command
lines.
A
I
think
that
makes
it
a
little
clearer.
So
here
I
am
whoops
seal
us
Here
I
am
in
my
fork,
and
you
can
see
this
is
turned
red.
So
that
gives
me
some
changes
and
the
first
command
I
want
to
show
you
is
get
status,
and
that
will
tell
you
what's
going
on
on
this
particular
branch.
What
changes
you've
made,
what
things
are
either
staged
or
unstaged,
and
you
can
read
this
and
it
pretty
much
just
spells
out
what's
going
on.
A
So
in
this
case,
it's
saying
change
is
not
staged
for
commit,
and
so
what
that
means
and
get
terminology
is.
We've
made
some
changes
to
this
file,
but
they're
just
sitting
here
locally
and
we
haven't
said
we're
going
to
commit
them
or
push
them.
Yet,
if
you're
unsure
about
changes
or
working
on
things,
it's
easier
to
not
commit
them,
then
to
uncommit
them,
though
you
can
always
uncommit
stuff
we're
not
going
to
cover
that
in
this
video,
but
just
to
keep
in
mind
I'll,
typically
work
on
my
changes.
A
Do
all
my
testing
make
sure
things
are
good.
Of
course
we
all
make
mistakes,
but
I'll
do
my
best
and
then
then
I'll
commit
things,
and
that
tends
to
keep
the
flow
a
little
bit
easier.
So
the
first
thing
I'm
gonna
do
is
a
command
or
a
second
thing.
I
guess
I
did
get
status
first,
we're
gonna,
do
get
add
and
I'm
gonna
put
a
period
here,
meaning
get
add
everything
in
this
folder
I
could
put
specific
files,
so
I
could
also
type
out
the
file
here
and
that
works
as
well.
A
Of
course
that's
a
bad
path,
but
so
we're
just
gonna
do
get
add
and
then
there's
the
star
and
now
I'm
gonna
do
get
status
again
and
so
we'll
see
after
doing
get
status.
After
doing
git
add
changes
to
be
committed.
That
file
now
falls
under
a
different
category
and
you
can
see
it's
listing
the
category
as
modified
so
sometimes
you'll
see
files
are
added,
sometimes
deleted
in
this
case
modified.
A
Typically,
your
changes
will
be
modified
unless
you're,
adding
new
content
or
deleting
some
files,
but
so
we've
got
our
modified
file
and
we've
added
it,
meaning
we're
ready
to
commit
it.
So
we've
sort
of
staged
it
to
be
committed
right,
and
so
we
feel
good
about
the
files
we've
added
we've
looked
looked
over
things
and
so
we're
gonna
do
get
commit
and
I
find
it
really
easy
to
use
the
em
command,
which
allows
you
to
attach
the
commit
message
right
on
the
command
line.
A
A
Exports
of
SP
library
and
that's
enough
right
that
tells
us
what
we've
done
and
for
those
of
us
that
are
reviewing
your
changes
that
you're
going
to
submit
as
pull
requests.
Creating
these
clear
commit
messages
really
helps
us
understand
the
changes
you've
made
and
what
we
should
be
looking
at
and
what
we
should
be
testing
when
we
do
testing
on
our
side,
so
I'm
gonna
hit
enter,
we've
got
that
committed
and
I'm
gonna
say
get
status
and
you'll
see.
Now
you
know
our
brand.
We
have
nothing
to
commit.
A
Our
working
tree
is
clean
because
we've
actually
committed
all
the
changes,
but
you
can
see
our
branch
is
ahead
of
origin
dev
by
three
commits,
and
so
three
commits
is
because
I've
actually
done
a
little
bit
of
other
work
before
this
video
and
we're
just
gonna.
Ignore
that
for
the
purpose
of
this
video
and
just
focus
on
the
one
commit
we
just
did
so,
the
last
command
we're
gonna
use
is
get
push
and
get
push
is
gonna.
A
Take
all
of
our
committed
changes
in
our
local
branch
and
are
gonna
push
those
up
into
our
forked
branch
on
github,
so
I'm
gonna
hit,
get
push
and
that's
gone
up
and
so
give
it
give
you
a
little
message.
If
you
have
a
lot
of
changes,
that'll
take
a
little
bit
longer,
but
it
shows
you
the
process.
It
went
through
to
commit
those
changes
and
then
where
it
sent
them
to
and
just
to
save
a
little
time,
I'm
going
to
copy
that
URL
and
I'm
gonna
come
here,
and
so
this
is
my
forked
github
repository.
A
Perhaps
so.
This
is
my
forked
github
repository
for
all
my
stuff
and
I'm
gonna
go
into
the
P
and
P
J
s.
So
again
this
is
forked
from
the
main
P
and
P
library,
and
so
we
can
see
we
get
the
same
message
here.
This
branch
has
three
commits
ahead
of
P
and
P
dev.
It
actually
lists
our
last
commits
up
here
for
us
adding
SP
batch
to
exports
of
SP
library.
So
now
we
want
to
take
from
our
fork.
A
We
want
to
submit
a
pull
request
back
to
the
main
branch
and
then
the
easiest
way
to
do
that
is
hit
this
new
pull
request
button.
So
we'll
give
this
a
second
to
load
up
and
there's
a
couple
things.
We
want
to
do
to
be
good
good
community
contributors
and
provide
a
little
bit
of
details
to
help
those
of
us
reviewing
these
changes.
I
have
a
little
bit
easier
time.
Looking
at
this
stuff,
so
we're
gonna
come
in
here
and
the
first
thing
you're
gonna
see
at
the
top.
A
Is
it
saying
it's
gonna
check
and
it's
gonna
say
you're
able
to
merge
and
the
only
time
you'll
really
see
that
it'll
say
you're
not
able
to
merge
is
where
maybe
you're
you've
got
a
much
older
fork.
You
didn't
do
that
update
at
the
beginning
with
get
pool
things
like
that,
and
you
can
always
then
fix
that,
and
you
can
actually
reach
in
to
your
fork
and
you
know,
update
your
pull
requests
or
create
those
pull
requests.
But
this
is
great.
We're
able
to
merge
these
branches
can
be
automatically
merged,
which
is
great.
A
You
can
actually
now
it'll
give
you
a
diff
of
all
the
different
files,
so
this
is
actually
the
change
we're
focused
on.
We
added
that
export
here
to
the
SP
TS
file
and
so
I'm
gonna
create
a
pull
request
with
all
my
changes
so
now.
This
is
where
you
can
really
help
us
to
review
your
changes
and
reviewer
updates
by
giving
us
nice
clear
instructions
as
to
the
changes
you've
made,
so
I'm
actually
just
going
to
copy
this
right
here,
so
adding
SP
to
there,
and
this
isn't
really
a
bug
fix.
A
This
is
a
new
feature,
so
we'll
say
a
new
feature
and
then
down
here
this
is
optional.
This
category,
please
do
give
us
the
category
that
helps
us
understand
sort
of
what's
coming
in
but
related
issues,
so
this
is
actually
going
to
fix
or
address
number
213
and
so
I'm
going
to
tag
it
here
and
say
to
13.
You
actually
get
a
little
prompt
there
to
help
you
and
then
it
says.
A
What's
in
this
pull
request,
so
please
describe
these
changes
and
we
have
added
SP
batch
class
to
the
exports
of
SP
library,
as
mentioned
in,
and
we're
just
gonna
tag
that
same
issue.
Again,
it's
it's
nice.
It
helps
us
again
the
link
things
together
and
then
we
can
go
ahead
and
delete
this
section
after
you've
read
it.
So
this
is
a
pretty
small
pull
request,
a
pretty
small
change.
So
this
is
sufficient.
A
We
don't
need
a
ton
of
detail,
but
we've
clearly
described
the
change
we've
made
and
this
lets
us,
as
the
reviewers
said:
what's
happened,
we've
added
this
class,
the
exports
great.
Let's
have
a
look
at
that.
You
can
preview
your
changes
of
course,
but
one
of
the
other
things
you
can
really
do
to
help
us
out
is
make
sure
if
you've
changed
multiple
files
or
changed
how
things
work
kind
of
put
the
details
or
that
in
here
we
don't
need
each
change
spelled
out.
A
We
can
look
at
the
code,
but
a
nice
outline
really
helps
us
understand.
The
changes
that
are
coming
in
someone
hit
create
pull
request
and
this
will
actually
create
the
pull
request
against
the
library
and
that's
it.
We
have
created
a
pull
request
against
the
P
and
P
sp,
sorry
P
PJs
library,
so
one
of
the
things
I'll
just
add.
That
really
is
it
for
you,
the
submitter
to
do
but
you'll
see
when
we
on
the
core
team
come
back
and
review
these
pull
requests.
A
You'll,
see
us
tag
them
with
a
version
number
and
we
try
and
do
that
to
make
sure
it's
very
clear
what
version
your
change
will
show
up
in.
So
you
can
see
your
pull
request
and
say
alright
great.
My
pull
request
was
accepted
and
I
can
expect
to
see
my
changes
in
whatever
version
might
get
tagged
on
it.
In
this
case,
one
one
five,
which
is
actually
gonna
go
out
this
week,
so
got
are
changes
in
we've
got
our
request,
so
hopefully
that
has
outlined
how
things
work.