All right, my friends, I'm back at my code editor inside my book directory, and those are three packages
right there.
So as you'd guess, we have to go through all these different steps for all three different packages.
Don't worry, it's not going to be that bad.
We pretty much have a good idea of what we need to do.
So let's just get right to it that no one here make sure our package names are unique.
That means we have to go round to all three of our different packages on files and make sure that whatever
we have written inside there for the name is a unique unus name on the NPM registry.
Well, I can just about guarantee you that the name Seelie is probably already in use.
Let's go back over to and just come inside of our browser and just verify that is the case.
So back at 9pm Dotcom.
I'll do a search for Seelie and yes, it definitely looks like there is already a package published
called Zeolite, that means that I cannot make use of the name Seelie and I'll need to think of some
different name.
In this case, I've decided to use the name James Note short for Jass Notebook.
So if I search for jazz note.
Yep, definitely, it looks like this is not in use just yet, there are some very similarly named projects,
but there's no existing package called Jazz Note.
So I can make use of this package name.
So for my Seelie, I'm going to rename.
DLI right there to just note now, once again, remember, I am making use of Jass notes, only one
person can use this package name.
That means that you are going to have to think of a different package name.
It can be just notes, mine jazz note.
Hey, ASDF, whatever you want.
It just cannot be.
Just note.
Now, we can repeat that same process for our other two packages on files, so we've got local API and
local clients, but before we just go and try to find some unique package names for those two, just
one quick note here.
Remember, local API and local client are really only consumed by our Seelie package.
So in other words, I don't really anticipate anyone is ever going to directly install local API onto
their machine.
I just don't think that's going to happen.
Same thing for local client as well.
I don't think anyone is going to try to manually install local client onto their machine.
The one thing we can do to logically group together these different packages on NPM and just make it
very clear to you and I that these packages are all somehow grouped together or used together, is assigned
these packages to what is called an organization.
Another term for this is to create a scoped package, you already make use of scope packages all the
time without really realizing it.
Or maybe, of course you do inside of my local API package.
JSON file.
I'm going to scroll down and go to the dependency section inside of here.
You'll notice we have eight types, of course, and at Types Express, these are scoped packages.
In this case, the organization that owns these packages is types.
That is the name of the organization.
By naming a package as a scope package, it just makes it very clear that at Type Korzen, at Type Express
or somehow related or managed by the same team.
So we might want to use a very similar pattern in our case and just make it very clear that local API
and local client are somehow tied together in some way.
However, we still might want to allow the ally to be named Jesus note or something very similar, we
might not want to scope this package just to keep the name of this package very simple and straightforward.
But people don't have to memorize.
Oh, yeah, I've type in at just notes, whatever, at their terminal whenever they tried to run Arkley.
So long story short, here's my idea.
I think we should do something like this.
I'm going to leave Seelie name does just note, but I'm then going to create some organization called
Jazz Note.
And I'm going to rename local API and local client to be scoped packages within that organization.
Now, of course, these names or the name of the organization in this case is going to be different
for you because very similar to package names.
Organization names have to be unique on NPM as well.
So you might end up with something like just note dash mine or just notes ASDF or whatever else you
want to put in there.
Now, one thing I just want to repeat here is that this is not strictly required, it's just a pattern
you're going to see very frequently, again, just to kind of logically grouped together packages and
make it clear that these things all kind of belong together in some way.
OK, so that's the general idea.
Let's take a pause right here.
We'll come back to the next video and we're going to create an organization to house our local and local
client packages.