open-index/open-npm huggingface dataset:
npm package: @lmiller1990/rhythm-engine
Description: - Install Node.js (obviously). I'm using v14. - Install [yarn](https://classic.yarnpkg.com/lang/en/). You want v1, aka "classic". One you installed it, `yarn -v` should give you something like `v1.22.10`. - Clone the project - Run `yarn install` to instal
Latest version: 0.0.4

This is a personal project. It's a simple rhythm game engine. There's a little demo app to test things out, but it's not really a fully fledged game. 

The engine isn't ready for use in any serious manner, but if you want to try it out, here's how.

## Dependencies

- Install Node.js (obviously). I'm using v14.
- Install [yarn](https://classic.yarnpkg.com/lang/en/). You want v1, aka "classic". One you installed it, `yarn -v` should give you something like `v1.22.10`.
- Clone the project
- Run `yarn install` to install all the dependencies.

## Running

NOTE: there is no guarentee `master` is in a working state.

- The project is bundled with [Rollup](https://rollupjs.org/guide/en/). You probably want to run rollup in watch mode. It will rebuild every time you change the code. Do that with `yarn build:demo --watch`.
- Start the dev server with `yarn start:demo`.
- Go to http://localhost:5000/demo
- Select a song with arrows keys and enter to start.
- The default is four columns. The buttons hard-coded to M < > ?. 
- The default scroll speed is also hard coded, but you can change that.
- Hit "r" to restart the song.
- There is no way to quit. You just need to refresh the page.

## Tests

Unlike the basic demo game, which is just hacked together to try things out, the tests are fully fleshed out and cover everything inside of `src`, which is where the engine lives. Any code change to `src` should have relevant tests added. Since the goal is an *engine*, not a fully fledge game, these must be up to date and coverage all the edge cases. This is the only practical way to work on something like this - testing by hand is time consuming and unreliabe.

## License

There is no license yet. If you really want to use this for something, contact me.
npm package: @lmiller1990/snippets
Description: Easily insert source code into documentation.
Latest version: 0.1.4

## Snippets

Easily insert source code into documentation.

## Quick Explanation

Snippets is a CLI tool to help keep your documentation and blog posts accurate by inserting code snippets from the actual repository.

The left side is what you write. The right side is what is generated automatically:

![](https://github.com/lmiller1990/snippets.io/blob/master/images/demo.png?raw=true)

### Installation

```
npm install -g @lmiller1990/snippets
```

### Usage

Let's say we are writing some documentation about an imaginary Node.js framework. We want to reference our file, `controllers/user.js`, in our documentation. It looks like this:

```js
class UsersController {
  constructor() {
  }

  index() {
  }
}
```

We are writing some documentation about how to add new controller actions. Let's teach the user to add a `show` action. 

Using snippets, we can write:

```
Add a `show` method to `controllers/users.js`.

You code should now look like:

//# master:controllers/users.js:1-3,8,9,10
```

We commit out changes, and run `snippets README.md`. This generates:


````
Add a `show` method to `controllers/users.js`.

You code should now look like:

```js
class UsersController {
  constructor() {
  }

  // ...

  show() {
  }
}
```
````

Any irrelevant lines are replaced with a `// ...` comment. Now you can easily and accurately include code samples in your blog post or documentation.

Note, `snippets` uses `git` to checkout files, so the code you are referencing needs to be checked into your git repository.

### Options

Formally, the full syntax is:

```
//# [branch]:[file]:[lines]?[commit hash]
```

A full example using all options would look like:

`//# master:controllers/users.js:1,2,3-6?ed53d197dac5da4a4a38a65bd7231b32fedaa6b1`.

### TODO

- [ ] correct comment based on snippet language
- [ ] landing page
- [ ] more examples/better documentation
- [ ] contributing guide
- [ ] simple blogging website with markdown UI, snippets backend
npm package: @lmiller1990/tea
Description: Tea is a very simple test runner. It's written for an upcoming YouTube and blog post series on how to build a test runner. It works with JavaScript and TypeScript.
Latest version: 0.0.14

## Tea

Tea is a very simple test runner. It's written for an upcoming YouTube and blog post series on how to build a test runner. It works with JavaScript and TypeScript.

Here's a simple snippet, using Tea with [must.js](https://github.com/moll/js-must) for the assertion library:

```ts
import demand from "must";
import { describe, it } from "@lmiller1990/tea";

const StringTools = {
  upcase(str: string) {
    return str.toUpperCase();
  },

  split(str: string, sep = " ") {
    return str.split(sep);
  },
};

describe("StringTools", () => {
  describe("upcase", () => {
    it("upcases the input", () => {
      const result = StringTools.upcase("message");
      demand(result).to.eql("MESSAGE");
    });
  });

  describe("split", () => {
    it("splits the input by white space", () => {
      const result = StringTools.split("a b c");
      demand(result).to.eql(["a", "b", "c"]);
    });
  });

  describe("example failure", () => {
    it("foo.bar is qux", () => {
      demand({ foo: { bar: "qux" } }).to.eql({ foo: { bar: "bar" } });
    });
  });
});
```

Running this produces the following output:

```sh
StringTools
  upcase
    ✔ upcases the input
  split
    ✔ splits the input by white space
  example failure
    ✗ foo.bar is qux

FAIL: foo.bar is qux
  Expected: {"foo":{"bar":"bar"}}
  Received: {"foo":{"bar":"qux"}}
```

## Installation

It's available on npm, but unstable and prone to change. This is not intended for production use, but for educational purposes. None the less, you can install it with `yarn add @lmiller1990/tea`.

## Local Development

- clone the repo
- `yarn install`
- `yarn build` to build (you need do to this when you make any changes to the source)
- `yarn demo:ts` to run a TypeScript test project
- `yarn demo:js` to run a JavaScript test project

## Design Goals

The code base is as small and simple as possible. It only provides the runner component, so you need to bring your own assertion library. The examples here use [must.js](https://github.com/moll/js-must).

## API

- `describe`
- `describe.only`
- `it`
- `it.only`

## Usage

If you test is written in JavaScript, just run `yarn tea <test files>`.

If you are using TypeScript, you can run using `ts-node`: `ts-node -T node_modules/.bin/tea demo.ts`. I might implement some kind of register API in the future, eg `yarn tea --register ts-node/register demo.ts`, but it is not implemented right now.