@fabiospampinato/template NPM

A super-simple way to create new projects based on templates.

A list of known active templates for this program can be found here.

Install

npm install -g @fabiospampinato/template

Usage

https://github.com/fabiospampinato/template/assets/1812093/4c53bf75-eb08-49c2-8b7f-8dae6dfa04eb

At a high level a template looks like this:

A template is just a folder installed locally simply by git clone-ing it into ~/.templates, or you can copy it manually there.
Each template has a folder named "template" inside it, which is what will be used for creating projects.
Each template has a "template.json" file inside it, which lists all variables used by files inside the "template" folder.
Each template may optionally have a folder named "hooks" inside it, containing files that will be executed at the appropriate times.

When creating a project from a template this happens:

The user is asked to provide a value for each variable listed by the template inside its "template.json" file.
The entire "template" folder inside the template is duplicated.
Each non-binary file inside this folder is rendered with picolate using the provided variables.
All rendered and binary files are copied in a newly created folder that has the name of the project you want to create.
The postinstall hook, if present, is executed.
That's it.

The following commands are available:

# Show help for the entire program
template --help

# Show help for a specific command
template install --help

# List all installed templates
template ls

# CD into an installed template
template cd my-template

# Install a template using a custom git endpoint
template install https://gitlab.com/some-user/some-repo.git my-template

# Install a template using a GitHub url
template install https://github.com/fabiospampinato/template-typescript-package typescript-package

# Install a template using a GitHub shorthand
template install fabiospampinato/template-typescript-package typescript-package

# Install a template from a local path
template install ./work-in-progress-template wip-template

# Automatically update all templates backed by git
template update

# Automatically update a specific template
template update my-template

# Uninstall a template
template uninstall my-template

# Create a new project from a template
template new typescript-package my-package

As mentioned in the "Overview" section a template must have this structure on disk:

.
├── hooks (optional)
│   └── postinstall.js (optional)
├── template
│   └── <anything>
└── template.json

You can put any files and folders you want under the "template" folder.
Everything inside it will be copied when creating a new project from it, and non-binary files will be rendered with picolate before saving them to disk.
Syntax highlighting for those files in your editor will probably be broken, but if you change the language to "Handlebars" it should look nice again.
Hooks are optional, each of them must export a function, that this program will call at the right times. Inside hooks process.cwd () will return the path of the new project.
The following hooks are supported:
- postinstall.js: it will be called right after a new project has been created. It will receive the object of variables used to render the project.

The "template.json" file should look somewhat like this:

{
  "delimiters": [ // This is optional
    "start": "[[",
    "end": "]]"
  ],
  "variables": {
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "version": {
      "type": "string",
      "default": "1.0.0"
    },
    "author": {
      "type": "string"
    },
    "owner": {
      "type": "string"
    },
    "scoped": {
      "type": "boolean"
    },
    "tested": {
      "type": "boolean"
    }
  }
}

Custom template delimiters that picolate will use can be provided, if you need them.
The user will be prompted to provide a value for each variable you list here.
You should list every single variable referenced by any of your template files.
A variable can either be of type "string" or of type "boolean".
A variable can also provide a default value, to allow the user to use that value quickly just by pressing enter.

As we saw in the "Templates Folder" section each template must provide a metadata "template.json" file, listing all the variables it uses, and optionally providing some default values for them.

There's also a way to override this metadata, by having a file at ~/.templates/templates.json that looks like this:

{
  "typescript-package": {
    "variables": {
      "author": {
        "default": "Fabio Spampinato"
      },
      "owner": {
        "default": "fabiospampinato"
      }
    }
  },
  "some-other-template": {
    "variables": {
      "someOtherVariable": {
        "default": "Some default value"
      }
    }
  }
}

This is very useful because:

In order for a template to be usable by a wide range of people it makes no sense to specify for example a default value for the "author" variable.
Still, once you install a template you probably know who the author is going to be, and you don't want to type out that informattion a million times, so this way you can override defaults for a template.