Registerable

Check if it can be registered as a package name or domain name

bundle size npm download

npm type definitions

🔖 Table of Contents

🔖 Table of Contents
✨ Features
- Module registry
📝 API
- CLI
  - Deno
  - Node.js
    - Local
    - Global
- JavaScript API
- Parameters
- Return value
- Definition of error
- Examples
💚 Supports
- ES modules
- UMD
:handshake: Contributing
🌱 Show your support
💡 License

✨ Features

⚡ Multi runtime support (Deno, Node.js)
📚 Pure TypeScript and provides type definition
:earth_americas: Universal module, providing ES modules and UMD
:package: Optimized, super slim size
📄 TSDoc-style comments

Module registry

📝 API

CLI

The Cli interface is common to Deno and Node.js.

@runtime <name> [Options]

@runtime: How to call it depends on the runtime. See Deno or Node.js sections.

name: Check module is registerable or not. required

Options:
All options are optional

flag	desc	type	default	choice
`-r`, `--registry`	Query to registry	`array`	[`deno.land`, `nest.land`, `npm`]	`deno.land`, `nest.land`, `npm`
`-j`, `--json`	Display to JSON format	`boolean`	`false`
`--verbose`	Verbose mode	`boolean`	`true`
`-h`, `--help`	Show help	`boolean`
`-v`, `--version`	Show version number

Deno

@runtime: deno run --allow-net https://deno.land/x/registerable/cli.ts

Configuration

Required permissions:

–allow-net

Local

You can use it directly from the CLI by using deno run:

deno run --allow-net https://deno.land/x/registerable/cli.ts <name> [Options]

Global

You can also install it globally using the following:

deno install --allow-net -n registerable https://deno.land/x/registerable/cli.ts

Then, the package is available to run:

registerable <name> [Options]

Node.js

Local

You can install locally.

yarn add -D registerable
or
npm i -D registerable

then,

yarn registerable <name> [Options]
or
npm run registerable <name> [Options]

Global

You can also install it globally using the following:

yarn global add registerable

registerable <name> [Options]

JavaScript API

The JavaScript API is the best way to call it programmatically.

Type Definition:

declare const registerable: <T extends "nest.land" | "npm" | "deno.land">(name: string, option?: Partial<Option<T>> | undefined) => Promise<RegisterableResult<T>>;

Parameters

registerable(name, option)

This function accept 2 arguments.

name [`required`]

name	type	desc
`name`	`string`	Query name

option [`optional`]

name	type	desc	default
`registry`	`array`	Pick the package registry to query. choice: `deno.land`, `nest.land` and `npm`	[`deno.land`, `nest.land`, `npm`]
`mode`	`string`	Specifies where this function is called. choice: `server` or `universal`	`server`

What is mode?

You can avoid CORS errors by specifying the mode. For server mode, it queries the public API in the package registry directly.

With the exception of deno.land, the public api response headers do not have the Access-Control-Allow-Origin property set. That is, if call this function from browser, you will get a CORS error.

To avoid this, we have prepared a Proxy server. It returns the result of running the registerable function on the server and the response header with Access-Control-Allow-Origin: * added.

You can get the result from the following URL:

https://registerable.vercel.app/check-name

Mode of universal queries this URL and gets the same results as server mode without CORS errors.

If there is a possibility of calling the registerable function from a Browser such as SPA or SSR, the mode should be universal.

However, if it is clear that it will be called only on the server side, it is recommended to use in server mode from the viewpoint of performance. Therefore, it is set to server mode by default.

Return value

The return value is a JSONObject that indicates whether it can be registered in the package registry, an error message if there is a validation error in query name, and which query caused the error.

{
  result: {
    "deno.land"?: boolean,
    "nest.land"?: boolean,
    npm?: boolean,
  },
  error: {
     "deno.land"?: string,
     "nest.land"?: string,
      npm?: string,
  },
  hasError: boolean,
  errorRegistry: ("deno.land" | "nest.land" | npm)[],
  name: string,
}

name	desc
`name`	Same as query name
`result`	Map of registry name and result of registerable or not
`error`	Map of registry name and validation error message
`hasError`	Set this flag to `true` if each registry query has more than one name validation error.
`errorRegistry`	List the registry names that had validation errors

Definition of error

If the package name exists, it will not be treated as an error. Violation of the package name rules in each package registry will report an error.

Click here for package name validation rules.

For example, if there is a validation error as the package name for deno.land and nest.land :

const { result, error, errorRegistry } = await registerable('exist-package-name')
// result 
{
  result: {
    "deno.land": false,
    "nest.land": false,
    npm: true,
  },
  error: {
     "deno.land": "Name contains only the characters a-z, 0-9 and _",
     "nest.land": "Name contains only the characters a-z, 0-9 and _",
  },
  hasError: true,
  errorRegistry: ["deno.land", "nest.land"],
  name: "exist-package-name",
}

errorRegistry.forEach((registry) => console.warn(registry, error[registry]))
// deno.land "Name contains only the characters a-z, 0-9 and _"
// nest.land "Name contains only the characters a-z, 0-9 and _"

Examples

await registerable('not_exist_package')
// result 
{
  result: {
    "deno.land": true,
    "nest.land": true,
    npm: true,
  },
  error: {},
  hasError: false,
  errorRegistry: [],
  name: "not_exist_package",
}

await registerable('not_exist_package', {
  registry: ['deno.land']
})
// result 
{
  result: {
    "deno.land": true
  },
  error: {},
  hasError: false,
  errorRegistry: [],
  name: "not_exist_package",
}