open-index/open-npm huggingface dataset:
npm package: @jbfulgencio/svelte-simplebar
Description: A Svelte wrapper for SimpleBar
Author: João Batista Fulgêncio
Latest version: 1.0.0

# svelte-simplebar
A Svelte wrapper for SimpleBar

## Installation
### Npm
    npm install --save @woden/svelte-simplebar
### Yarn
    yarn add @woden/svelte-simplebar
    
## Basic Usage
```html
<script>
import SimpleBar from '@woden/svelte-simplebar'
</script>

<SimpleBar style="height: 200px; width: 200px">
    <p>
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </p>
</SimpleBar>
```

## Props
| Name | Type | Description | Default value |
| ---- | ---- | ----------- | ------------- |
| `autoHide` | Boolean | Lorem ipsum dolor sit amet | true |
| `scrollbarMinSize` | Number | Define the minimum scrollbar size in pixels. | 10 |
| `scrollbarMaxSize` | Number | Define the maximum scrollbar size in pixels. | 0 |
| `classNames` | Object | It is possible to change the default class names that SimpleBar uses. To get your own styles to work refer to simplebar.css to get an idea how to setup your css. [For more informations](https://github.com/Grsmto/simplebar/tree/master/packages/simplebar#classnames) | ```{ content: 'simplebar-content', scrollContent: 'simplebar-scroll-content', scrollbar: 'simplebar-scrollbar', track: 'simplebar-track' }``` |
| `forceVisible` | Boolean | You can force the track to be visible (same behaviour as overflow: scroll) using the forceVisible option. | false |
| `direction` | String | You can activate RTL support by passing the direction option | 'ltr' |
| `timeout` | Number | Define the delay until the scrollbar hides. Has no effect if autoHide is false. | 1000 |
| `clickOnTrack` | Boolean | Controls the click on track behaviour. | true |
| `class` | String | Apply one or more css class(es) on the component | none |
| `style` | String | Apply css inline styles on the component | none |

## Events
| Name | Description |
| ---- | ----------- |
| `scrollXReachStart` | This event fires when scrolling reaches the start of the x-axis. |
| `scrollXReachEnd` | This event fires when scrolling reaches the end of the x-axis. |
| `scrollYReachStart` | This event fires when scrolling reaches the start of the y-axis. |
| `scrollYReachEnd` | This event fires when scrolling reaches the end of the y-axis. |
npm package: @jbirch8865/reacttour
Description: training steps used with jbirch8865 laravel backends
Author: Joel Birch
Latest version: 1.0.10

# reacttour

> training steps used with jbirch8865 laravel backends

[![NPM](https://img.shields.io/npm/v/reacttour.svg)](https://www.npmjs.com/package/reacttour) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save reacttour
```

## Usage

```jsx
import React, { Component } from 'react'

import MyComponent from 'reacttour'
import 'reacttour/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [jbirch8865](https://github.com/jbirch8865)
npm package: @jbiskur/nestjs-async-module
Description: The Async Module is a utility class, that simplifies creating dynamic NestJS modules.
Latest version: 5.1.1

# nestjs-async-module

The Async Module is a utility class, that simplifies creating dynamic NestJS modules.

[toc]: # "## Table of Contents"

- [Installation](#installation)
- [Usage](#usage)

## Installation

Install using npm.

```npm
npm install --save-dev @jbiskur/nestjs-async-module
```

using yarn.

```yarn
yarn add --dev @jbiskur/nestjs-async-module
```

## Usage

The library provides a utility class and an options factory

```typescript
//...nestjs imports
import { AsyncModule, AsyncOptions } from "@jbiskur/nestjs-async-module";

// interface for the module
interface ExampleOptions {
  name: string;
}

@Module({
  imports: [],
  controllers: [],
  providers: [],
  exports: [],
})
class ExampleAsyncModule extends createAsyncModule<ExampleOptions>() {}
```

to then use the module you just use the register async and then typescript uses the interface for intellisense.

```typescript
@module({
  imports: [
    ExampleAsyncModule.registerAsync(
      {
        useFactory: () => ({
          name: "hello world",
        }),
      },
      ExampleAsyncModule
    ),
  ],
})
export class AppModule {}
```

## Accessing Options

To access options registered with this dynamic module can be done with the following:

```typescript
@Injectable()
class ExampleService {
  constructor(private readonly options: ModuleOptions<ExampleOptions>) {}

  testOptions() {
    return this.options.get().name;
  }
}
```

The ModuleOptions service discovers all tokens noted with uppercase `_OPTIONS` within the current module, and they are flattened into the return of the `get()` method. TypeScript is informed via the template parameter `ModuleOptions<TOptions>`. These options are not validated on retrieval.

# Facilitate Injecting Services

another use-case is to purely use it to facilitate injecting services to dynamic modules.

```typescript
//...nestjs imports
import { AsyncModule, AsyncOptions } from "@jbiskur/nestjs-async-module";

@Module({
  imports: [],
  controllers: [],
  providers: [],
  exports: [],
})
class ExampleAsyncModule extends createAsyncModule() {}
```

using it is then as simple as the following.

```typescript
@module({
  imports: [
    ExampleAsyncModule.registerAsync(
      {
        imports: [SomeModule],
        inject: [AService],
      },
      ExampleAsyncModule
    ),
  ],
})
export class AppModule {}
```
npm package: @jbiskur/nestjs-options-module-factory
Description: The Options Module Factory provides a way to pass an options provider in the current import context by forcing the options provider to be resolved first. This is done through creating a module purely for containing and exporting the options provider.
Latest version: 5.1.1

# nestjs-options-module-factory

The Options Module Factory provides a way to pass an options provider in the current import context by forcing the options provider to be resolved first. This is done through creating a module purely for containing and exporting the options provider.

[toc]: # "## Table of Contents"

- [Installation](#installation)
- [Usage](#usage)

## Installation

Install using npm.

```npm
npm install --save @jbiskur/nestjs-options-module-factory @jbiskur/nestjs-async-module
```

using yarn.

```yarn
yarn add @jbiskur/nestjs-options-module-factory @jbiskur/nestjs-async-module
```

## Usage

The library provides a utility factory function that creates a module with the options provided. These options are exported and can be used in the import context as seen in the example below. The InnerTestModule injects the options module and uses the const import to inject in the options.

```typescript
// ...nestjs and async module imports
import { createOptionsModule } from "@jbiskur/nestjs-options-module-factory";

@Module({
  providers: [InnerTestService],
})
class InnerTestModule extends createAsyncModule<Options>() {}

@Module({})
class TestModule extends AsyncModule {
  public static registerAsync(options: AsyncOptions<Options>): DynamicModule {
    const optionsModule = createOptionsModule(OPTIONS_NAME, options);

    return this.doRegisterAsync(TestModule, null, null, {
      imports: [
        optionsModule,
        InnerTestModule.registerAsync(
          {
            imports: [optionsModule],
            inject: [OPTIONS_NAME],
            useFactory: (outerOptions: Options) => ({
              value: outerOptions.value,
            }),
          },
          InnerTestModule
        ),
      ],
      providers: [TestService],
    });
  }
}
```