open-index/open-npm huggingface dataset:
npm package: @rubeniskorg/esbuild-scripts
Description: <div align="center"> <h1>Create Esbuild App / esbuild-scripts 🔥</h1>
Latest version: 5.0.3

<div align="center">
<h1>Create Esbuild App / esbuild-scripts 🔥</h1>

<p>An extremely fast create-react-app replacement.</p>
</div>

---

<!-- prettier-ignore-start -->
[![Build](https://github.com/LukeSheard/esbuild-scripts/actions/workflows/node.js.yml/badge.svg)](https://github.com/LukeSheard/esbuild-scripts/actions/workflows/node.js.yml?query=branch%3Amain)
<!-- prettier-ignore-end -->

## What is it?

<img width="15%" align="right" src="https://esbuild.github.io/favicon.svg">

`create-esbuild-app` is a wrapper around `create-react-app` while `esbuild-scripts` is a `react-scripts` compatible CLI which can be dropped in as a replacement. They use the toolchain and development experience already provided by the Create React App ecosystem but provide an faster experience by abstracting esbuild as a bundler and using native esbuild plugins for speed.

`esbuild-scripts` in most cases should be a drop in replacement for `react-scripts`.

## Creating an App

```sh
yarn create @lukesheard/esbuild-app my-app
cd my-app
yarn start
```

If you've previously installed `create-esbuild-app` globally you can run `yarn global remove create-esbuild-app` to remove it - this will ensure that you always use the latest version when creating a new app.

**Note:** The API of `create-esbuild-app` mirrors that of `create-react-app` but will default the template of a new app to _TypeScript_. However if you want to use a custom template you can do so
by supplying a `--template` argument like so

```sh
yarn create @lukesheard/esbuild-app my-app --template my-template
```

Supplying an empty template will default to the JavaScript template from `create-react-app`. This is because in most instances I've noticed users default to this template anyway - so I wanted to abstract this in a way which made it simple to pick convetional defaults.

For more documentation on creating an App refer to the [Create React App documentation](https://create-react-app.dev/docs/folder-structure).
npm package: @rubenj01/tsoptional
Description: A container object that helps dealing with null values.
Author: Ruben Eekhof
Latest version: 1.0.8

![NPM Version](https://img.shields.io/npm/v/%40rubenj01%2Ftsoptional) ![GitHub License](https://img.shields.io/github/license/RubenJ01/tsoptional)

# TSOptional
A Java inspired Optional type implemented in TypeScript.

## Installation
```npm
npm i @rubenj01/tsoptional
```

## Why use an Optional?
Here I will list a few advantages of using Optionals in your code.

### 1. Null Safety
Using an Optional handles the absence of a value without using null. Null values in any code are a common source of bugs.
Example:
```ts
function getValue(): string | null {
    if(found) {
        return value;
    }
    return null;
} 
```
The above pseudocode will return the value if its found, and null otherwise. 
If we want to use the value of this function elsewhere we will have to do a nullcheck everywhere its called.
Not only can this be forgotten, it can also lead to null values accidentaly ending up in your code.
We can make this function return an Optional instead:
```ts
function getValue(): Optional<string> {
    if(found) {
        return Optional.of(value);
    }
    return Optional.empty();
} 
```
Now, everytime this function is called and we want to use its value we have to take it out of the Optional, we can do this with the get() function. 
This function will throw an exception if the Optional is empty basically forcing you to check if its empty or not. This can be done with the ifPresent() function:
```ts
let value = getValue();
if(value.isPresent()) {
    console.log(`Optional contains value ${value.get()}`);
} else {
    console.log("Optional is empty");
}
```

### 2. Eliminates null checks
Optional provides methods to deal with the presence or absence of a value, reducing the need for repetitive null checks and making the code cleaner and easier to read.
```ts
let value = getValue();
value.ifPresentOrElse(
    (value) => console.log(`Optional contains value ${value}`), 
    () => console.log("Optional is empty")
);
```

## Usage
**Importing:**
```ts
import { Optional } from "@rubenj01/tsoptional";
```

**Creating an Optional with a value:**
```ts
Optional.of("someValue");
```

**Creating an empty Optional:**
```ts
Optional.empty();
```

**Retrieving a value:**
```ts
Optional.get();
```
npm package: @rubennic/guidedog
Description: Guide Dog is an experiment in regression testing for accessability.
Author: Ruben Niculcea
Latest version: 0.0.8

# Guide Dog
## This is only a prototype. 
## It will not work as intended! 
## Here be dragons. 
##### Beware of Dog. 

Guide Dog is an experiment in regression testing for accessability.

It currently only works with React components, which can then be "snapshotted" with jest to tell when  element changes produce accessability changes.

Guide Dog can produce:
- Accessability tree
- Tabable elements tree
- Landmarks tree

## Usage:
```bash
yarn add --dev @rubennic/guidedog
```

In your jest file:
```jsx
import { guideDog, GuideDogFilter } from '@rubennic/guidedog';

test('guideDog test', async () => {
  const accessibilityTree = await guideDog(<TestComp/>);
  expect(accessibilityTree).toMatchSnapshot();

  const tabableTree = await guideDog(<TestComp/>, {
    filterType: GuideDogFilter.OnlyTabableElements,
  });
  expect(tabableTree).toMatchSnapshot();

  const landmarksTree = await guideDog(<TestComp/>, {
    filterType: GuideDogFilter.OnlyLandmarks,
  });
  expect(landmarksTree).toMatchSnapshot();
});
```

## A few of it's current limitations:

1. Super slow. This is due to using puppeteer to generate accessability trees.
2. Invalid snapshots do not link back to offending react components.

I'm working on ideas for all of the above problems.