# @cyclist/schema

> Schema and types for cyclist configs

Latest version **0.1.0** (published 2020-10-01) · MIT license · 0 weekly downloads

## Install

```sh
npm install @cyclist/schema
pnpm add @cyclist/schema
yarn add @cyclist/schema
bun add @cyclist/schema
```

## Health

**Score 20/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities.

Warnings: low downloads; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.0 |
| Published | 2020-10-01 |
| First published | 2020-10-01 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 5.2 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 3 |
| Author | dpisani |
| Maintainers | dpisani |

## Links

- npm: https://www.npmjs.com/package/@cyclist/schema
- Repository: https://github.com/dpisani/cyclist
- Issues: https://github.com/dpisani/cyclist/issues
- npm.io page: https://npm.io/package/@cyclist/schema

## Recent versions

- 0.1.0 (latest) — 2020-10-01

## README

# Cyclist: Build lifecycles for JS projects 🚴

Cyclist makes it easier to build, test and run your code by ensuring all the necessary build steps needed
to achieve something are run in the right sequence every time. This can be especially useful when your code needs
to be compiled before it can be run by node or other tooling.

## Getting started

The main way to use Cyclist is via the CLI:

```bash
npm install -g @cyclist/runner
# or if using yarn
yarn global add @cyclist/runner
```

Cyclist works by executing your npm scripts in a defined order, called a _lifecycle_. These would normally
correspond to common workflows when working in your project. For example, a lifecycle for building and publishing a package
might look like:

```
clean -> lint -> build -> publish
```

We can configure this lifecycle by defining it in our `package.json`:

```json
{
  "cyclist": {
    "lifecycles": {
      "package": ["clean", "lint", "build", "publish"]
    }
  }
}
```

Then, in the terminal we can run

```bash
cyclist package
```

which will run all the corresponding `scripts` in our `package.json` for all the stages in the `package` lifecycle. We can also execute a lifecycle part-way by providing the name of a different stage, which will only run stages up to and including the one specified, e.g.

```bash
cyclist package build
```

will run only the `clean`, `lint`, and `build` scripts. This can be useful to verify the output of different parts of the lifecycle and
to facilitate different needs throughout the development flow.

More details about using and configuring lifecycle runner CLI can be found in the [@cyclist/runner docs](./packages/runner/README.md)

## Inspiration

- [Preconstruct](https://github.com/preconstruct/preconstruct) - a great tool for a smooth workflow in monorepos
- [Maven](https://maven.apache.org/) - contains lots of battle-hardened wisdom on how to do builds

---
_Source: https://npm.io/package/@cyclist/schema · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._