open-index/open-npm huggingface dataset:
npm package: @pvnguyen123/ember-cli-feather-icons
Description: The default blueprint for ember-cli addons.
Latest version: 0.0.5

ember-cli-feather-icons
==============================================================================

This is a ember addon that allows projects to use feather icons library.

Installation
------------------------------------------------------------------------------

```
ember install @pvnguyen123/ember-cli-feather-icons
```


Usage
------------------------------------------------------------------------------

Basics
{{fe-icon name size}}

Availabe sizes:
sm: 20
md: 24 -- Default
lg: 36
xlg: 48

Example:
{{fe-icon 'arrow-right'}}
{{fe-icon 'arrow-right' 'lg'}}


Contributing
------------------------------------------------------------------------------


License
------------------------------------------------------------------------------

This project is licensed under the [MIT License](LICENSE.md).
npm package: @pvorona/counter
Description: A tiny mutable counter.
Latest version: 0.1.3

# @pvorona/counter

A tiny mutable counter.

## Install

```bash
npm i @pvorona/counter
```

## Usage

```ts
import { createCounter } from '@pvorona/counter';

const counter = createCounter(5);

counter.value; // 5
counter.increment(); // 6
counter.set(20); // 20
counter.reset(); // 5
counter.value; // 5
```

## API

### `type Counter`

Public counter interface.

```ts
export type Counter = {
  readonly value: number;
  increment(amount?: number): number;
  decrement(amount?: number): number;
  set(value: number): number;
  reset(): number;
};
```

Notes:

- `value` is the current count.
- `increment(amount?)` adds `amount` (defaults to `1`) and returns the updated value.
- `decrement(amount?)` subtracts `amount` (defaults to `1`) and returns the updated value.
- `set(value)` replaces the current value and returns it.
- `reset()` restores the original `initialValue` and returns it.

Example:

```ts
import type { Counter } from '@pvorona/counter';

function reset(counter: Counter) {
  counter.reset();
}
```

### `createCounter(initialValue?: number): Counter`

Creates a new counter.

- **`initialValue`**: starting value (defaults to `0`)
- **returns**: a `Counter`

Example:

```ts
import { createCounter } from '@pvorona/counter';

const clicks = createCounter();
clicks.increment(); // 1
```
npm package: @pvorona/noop
Description: A tiny no-op function.
Latest version: 0.0.5

# @pvorona/noop

A tiny no-op function.

## Install

```bash
npm i @pvorona/noop
```

## Usage

```ts
import { noop } from '@pvorona/noop';

element.addEventListener('scroll', handler ?? noop);
```

Another common use: default optional callbacks.

```ts
import { noop } from '@pvorona/noop';

export function withFinally(run: () => void, onFinally: () => void = noop) {
  try {
    run();
  } finally {
    onFinally();
  }
}
```

## API

### `noop(): void`

Does nothing and returns `void`.

Notes:

- You can pass `noop` where a callback is required but you have nothing to do.
- In JavaScript, extra arguments are ignored, so `noop` is also safe as a fallback for many event handler types.

Example:

```ts
import { noop } from '@pvorona/noop';

const onError: (e: unknown) => void = noop;
```
npm package: @pvorona/not-implemented
Description: A typed `TODO` for code paths that haven't been implemented yet.
Latest version: 0.0.5

# @pvorona/not-implemented

A typed `TODO` for code paths that haven't been implemented yet.

## Install

```bash
npm i @pvorona/not-implemented
```

## Usage

```ts
import { notImplemented, NotImplementedError } from '@pvorona/not-implemented';

type Shape = 'circle' | 'square' | 'triangle';

function area(shape: Shape): number {
  switch (shape) {
    case 'circle':
      return Math.PI * r * r;
    case 'square':
      return side * side;
    case 'triangle':
      notImplemented('Triangle area');
  }
}

// Custom error handling
try {
  notImplemented();
} catch (e) {
  console.log(e instanceof NotImplementedError); // true
  console.log(e.message); // 'Not implemented'
}
```

## API

### `class NotImplementedError extends Error`

An `Error` subclass thrown by `notImplemented()`.

Example:

```ts
import { NotImplementedError } from '@pvorona/not-implemented';

const err = new NotImplementedError('Feature X');
err.name; // "NotImplementedError"
```

### `notImplemented(message?: string): never`

Throws a `NotImplementedError` with a clean stack trace.

- **`message`**: optional message (defaults to `"Not implemented"`)
- **returns**: `never` (it always throws)

Example:

```ts
import { notImplemented } from '@pvorona/not-implemented';

export function decodeBase32(_input: string): Uint8Array {
  notImplemented('decodeBase32');
}
```
npm package: @pvorona/resolve-value-or-getter
Description: Resolve a literal value or lazily compute it from a zero-argument getter.
Latest version: 0.1.2

# @pvorona/resolve-value-or-getter

Resolve either a literal value or a lazy zero-argument getter.

## Install

```bash
npm i @pvorona/resolve-value-or-getter
```

## Usage

```ts
import { resolveValueOrGetter } from '@pvorona/resolve-value-or-getter';

resolveValueOrGetter('value'); // 'value'
resolveValueOrGetter(() => 'computed'); // 'computed'
```

## API

### `resolveValueOrGetter(valueOrGetter)`

Accepts either:

- a non-function value
- a zero-argument getter returning a non-function value

Returns the value directly, or calls the getter and returns its result.

Function values are intentionally not supported, because a function input is
reserved for the lazy getter form.
npm package: @pvorona/throw-error
Description: Throw errors with clean stack traces pointing at the caller, not the internals.
Latest version: 0.0.5

# @pvorona/throw-error

Throw errors with clean stack traces pointing at the caller, not the internals.

## Install

```bash
npm i @pvorona/throw-error
```

## Usage

```ts
import { throwError } from '@pvorona/throw-error';

function parsePort(input: string): number {
  const port = Number(input);

  if (!Number.isInteger(port) || port <= 0 || port >= 65536) {
    throwError(new RangeError(`Invalid port: ${input}`));
    // Stack trace points here ^, not inside throwError
  }

  return port;
}
```

### Skipping extra stack frames

```ts
function validateEmail(input: string): string {
  if (!input.includes('@')) {
    // Stack trace will skip validateEmail and point at its caller
    throwError(new Error('Invalid email'), validateEmail);
  }

  return input;
}
```

## API

### `throwError(error: Error, functionToSkipStackFrames?: Function): never`

Throws `error`, attempting to make its stack trace point at the caller (instead of the `throwError` internals).

- **`error`**: the error to throw
- **`functionToSkipStackFrames`**: a function to pass as the “stack start” (defaults to `throwError`)
  - Use this when you have a helper wrapper and want to hide that wrapper from the stack trace.

Notes:

- Uses `Error.captureStackTrace` when available (Node/V8). In other runtimes, it simply throws.
- The return type is `never`, so it plays nicely with guard-clause control flow.

Example (wrapping):

```ts
import { throwError } from '@pvorona/throw-error';

export function invariant(condition: unknown, message: string): asserts condition {
  if (condition) return;
  throwError(new Error(message), invariant);
}
```
npm package: @pvtnbr/pkg-size
Description: Measure the size of your npm package distribution
Author: Hiroki Osame
Latest version: 1.2.0

<p align="center">
	<br>
	<br>
	<img width="70%" src=".github/screenshot.png">
	<br>
	<a href="https://npm.im/@pvtnbr/pkg-size"><img src="https://badgen.net/npm/v/@pvtnbr/pkg-size"></a>
	<a href="https://npm.im/@pvtnbr/pkg-size"><img src="https://badgen.net/npm/dm/@pvtnbr/pkg-size"></a>
	<a href="https://packagephobia.now.sh/result?p=@pvtnbr/pkg-size"><img src="https://packagephobia.now.sh/badge?p=@pvtnbr/pkg-size"></a>
	<br>
	<br>
	<i>Measure the size of your npm package distribution</i>
</p>

**⚡️ Try it in your npm package**

```sh
$ npx @pvtnbr/pkg-size
```

<sub>If you like this project, please star it & [follow me](https://github.com/privatenumber) to see what other cool projects I'm working on! ❤️</sub>

## 🙋‍♂️ Why?
- **🔍 Size analysis** Quickly determine the total size of what you're publishing to npm!
- **🔥 Same behavior as npm `pack`/`publish`** Collects publish files as specified in your `package.json`!
- **🙌 Gzip & Brotli** See how your files compress in addition to normal size!
- **🤖 Node.js API** Integrate size checks to your CI via Node.js API

## 🚀 Install
```sh
npm i @pvtnbr/pkg-size
```

## 🚦 Quick Usage
```js
const pkgSize = require('@pvtnbr/pkg-size');

// Get package size data from current working directory
const sizeData = await pkgSize();

// Get package size data from a specific package path
const sizeData = await pkgSize('/path/to/package');
```

## ⚙️ API
```ts
type FileEntry = {
    path: string;
    mode: number;
    size: number;
    sizeGzip: number;
    sizeBrotli: number;
};

type PkgSizeData = {
    pkgPath: string;
    tarballSize: number;
    files: FileEntry[];
};

function pkgSize(pkgPath?: string): Promise<PkgSizeData>;
```