open-index/open-npm huggingface dataset:
npm package: @filipevoges/isset
Description: PHP isset function equivalent in Javascript
Author: Filipe Voges
Latest version: 1.1.0

![build](https://github.com/filipevoges/isset/actions/workflows/node.js.yml/badge.svg)

# isset
`isset` for javascript - inspired by [php](https://www.php.net/manual/en/function.isset.php)

## Installation
```bash
npm install --save filipevoges/isset
```

## Example usage

```javascript
import('@filipevoges/isset');

"1".isset()                 // True
[].isset()                  // True
[].isset("foo")             // false
[].isset(0)                 // false
["foo"].isset("foo")        // false
["foo"].isset(0)            // True
{}.isset()                  // True
{0: "foo"}.isset(0)         // True
{0: "foo"}.isset("foo")     // false
isset(1)                    // True
isset("1")                  // True
isset([])                   // True
isset([], "foo")            // false
isset([], 0)                // false
isset(["foo"], "foo")       // false
isset(["foo"], 0)           // True
isset({})                   // True
isset({0: "foo"}, 0)        // True
isset({0: "foo"}, 1)        // false
isset({0: "foo"}, "foo")    // false
```

## Issues

If there is any problem, please report on [Issues page](https://github.com/FilipeVoges/isset/issues)
npm package: @filipgorny/types
Description: Shared TypeScript types for the monorepo
Author: Filip Gorny
Latest version: 0.0.2

# @filipgorny/types

Shared TypeScript types for the monorepo.

## Warning

This package is under development. APIs may change without notice.

## Installation

```bash
npm install @filipgorny/types
```

## Exported Types

- `ClassType<T = any>`
- `AbstractClassType<T = any>`
- `FactoryFunction<T = any>`
- `AsyncFactoryFunction<T = any>`

## Usage Examples

### ClassType

```typescript
import { ClassType } from '@filipgorny/types';

class MyClass {
  constructor(value: string) {}
}

const MyClassType: ClassType<MyClass> = MyClass;
const instance = new MyClassType('hello');
```

### AbstractClassType

```typescript
import { AbstractClassType } from '@filipgorny/types';

abstract class AbstractClass {
  abstract method(): void;
}

const AbstractType: AbstractClassType<AbstractClass> = AbstractClass;
// Cannot instantiate directly, used for typing abstract constructors
```

### FactoryFunction

```typescript
import { FactoryFunction } from '@filipgorny/types';

const createString: FactoryFunction<string> = (prefix: string) => `${prefix} world`;
const result = createString('hello'); // 'hello world'
```

### AsyncFactoryFunction

```typescript
import { AsyncFactoryFunction } from '@filipgorny/types';

const createAsyncString: AsyncFactoryFunction<string> = async (prefix: string) => {
  await new Promise(resolve => setTimeout(resolve, 100));
  return `${prefix} world`;
};

const result = await createAsyncString('hello'); // 'hello world'
```

## API Documentation

### ClassType<T = any>

A type representing a constructor function that creates instances of type `T`.

- **Type Parameters**: `T` - The type of the instance created by the constructor.
- **Signature**: `new (...args: any[]) => T`

### AbstractClassType<T = any>

A type representing an abstract constructor function for abstract classes.

- **Type Parameters**: `T` - The type of the abstract class.
- **Signature**: `abstract new (...args: any[]) => T`

### FactoryFunction<T = any>

A type representing a synchronous factory function that returns an instance of type `T`.

- **Type Parameters**: `T` - The return type of the factory function.
- **Signature**: `(...args: any[]) => T`

### AsyncFactoryFunction<T = any>

A type representing an asynchronous factory function that returns a promise resolving to type `T`.

- **Type Parameters**: `T` - The resolved type of the promise.
- **Signature**: `(...args: any[]) => Promise<T>`
npm package: @filiph/sveltekit-adapter-firebase
Description: Adapter for SvelteKit apps that generates a Firebase Function
Latest version: 1.0.2

# @filiph/sveltekit-adapter-firebase

[Adapter](https://svelte.dev/docs/kit/adapters) for SvelteKit apps that generates a Firebase Function definiton.

## Docs

This adapter is published only for author's uses, but feel free to use.

Requirement is to have functions directory according to Firebase docs. Optionally you can change outputs of the code, see type declarations.
Generates similar code to node adapter, but with different request parsing. The function is exported as `handler`.

## Changelog

[The Changelog for this package is available on GitHub](https://github.com/Hejtmus/sveltekit-adapter-firebase/blob/master/CHANGELOG.md).

## License

[MIT](LICENSE)
npm package: @filiphsandstrom/react-currency-formatter
Description: Somewhat maintained version of react-currency-formatter
Author: Filiph Sandström
Latest version: 1.1.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# 💵 react currency formatter

[![npm](https://img.shields.io/npm/dt/react-currency-formatter.svg)](https://www.npmjs.com/package/react-currency-formatter)
[![npm](https://img.shields.io/npm/v/react-currency-formatter.svg)](https://www.npmjs.com/package/react-currency-formatter)
[![David](https://img.shields.io/david/xDae/react-currency-formatter.svg)](https://david-dm.org/xDae/react-currency-formatter)
[![Travis](https://img.shields.io/travis/xDae/react-currency-formatter.svg)](https://travis-ci.org/xDae/react-currency-formatter)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)]()


### 💻  [DEMO!](https://xdae.github.io/react-currency-formatter/)

## Usage

#### Simple
```js
import Currency from 'react-currency-formatter';

<Currency
  quantity={45685}
  currency="EUR"
/>
```

#### Complex
```js
import Currency from 'react-currency-formatter';

<Currency
  quantity={45685}          // Required
  currency="USD"            // Optional (USD by default)
  locale="en_EN"            // Optional
  pattern="##,### !"        // Optional
  decimal=","               // Optional
  group="."                 // Optional
/>
```

#### TypeScript

```ts
import * as React from 'react'
import * as CurrencyFormatter from 'react-currency-formatter'

type Props = {
	price: number,
	currency: string,
}

const ProductionPrice: React.SFC<Props> = (props: Props) => (
	<CurrencyFormatter quantity={props.price} currency={props.currency} />
)

export default ProductionPrice
```

## Support

Please [open an issue](https://github.com/xDae/react-currency-formatter/issues/new) for support.

## Contributing

Please contribute using [Github Flow](https://guides.github.com/introduction/flow/). Create a branch, add commits, and [open a pull request](https://github.com/xDae/react-currency-formatter/compare/).