open-index/open-npm huggingface dataset:
npm package: @rhtml/cli
Description: Rhtml CLI tool
Author: Kristiyan Tachev
Latest version: 0.0.30

# @rhtml/cli

#### Installation

```bash
npm i @rhtml/cli -g
```

#### Usage

##### Generate schematic can be 'module', 'controller', 'service'

```bash
rhtml generate --name test --type module
```

##### General Help

```bash
Usage: rhtml [options] [command]

Options:
  -V, --version       output the version number
  -h, --help          display help for command

Commands:
  generate [options]  Generate specific schematic
  help [command]      display help for command
```

##### Generate Help

```bash
Usage: rhtml generate [options]

Generate specific schematic

Options:
  -n, --name <name>      Name of the generated schematic
  -t, --type <type>      Specify type name can be one of the followings "controller", "module", "service"
  -f, --force            Force create schematics even with errors
  --language <language>  Language can be ts or js
  --folder <folder>      Choose folder where schematics will be generated default is src/app
  --dry-run              Dry run the command to see if the folder structure will be correct
  --spec                 Whether or not to create .spec tests when creating schematics
  -h, --help             display help for command
```
npm package: @rhtml/components
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/components

#### Installation

```bash
npm i @rhtml/components
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';
import { BehaviorSubject } from 'rxjs';
import { delay } from 'rxjs/operators';

import '@rhtml/components';

interface State { counter: number }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-renderer
        .options=${{
          state: new BehaviorSubject({ counter: 1 }).pipe(
            delay(1700),
          ),
          render: (
            res: State,
            setState: (res: State) => State
          ) =>
            html`
              <r-button
                palette="danger"
                @click=${() => setState({ counter: res.counter + res.counter })}
                >Increment</r-button
              >
              ${res.counter}
            `,
          loading: () => html`adadadad`,
          error: () => html`adadadadadada`
        }}
      ></r-renderer>

      <r-for .of=${['IterableItem 1', 'Iterable Item 2']}>
        <r-let .item=${v => html``}></r-let>
      </r-for>

      <r-part>
        <r-state .value=${this.select(res => res.data.randomName)}></r-state>
        <r-render .state=${name => html`
          <p>${name}</p>
        `}>
        </r-render>
      </r-part>

      <r-part>
        <r-settings .value=${{ fetchPolicy: 'cache-first' }}></r-settings>
        <r-fetch query="{
          continents {
            name
          }
        }"></r-fetch>
        <r-render .state=${({ data: { continents } }: IQueryData) => html`
          <r-for .of=${continents}>
            <r-let .item=${({ name }: IContinent) => name}></r-let>
          </r-for>
        `}>
        </r-render>
      </r-part>

      <r-part>
        <r-fetch subscribe="{ notifications { appUpdated } }"></r-fetch>
        <r-render .state=${({ data: { notifications: { appUpdated }}}) => html`
          <p>${appUpdated}</p>
        `}>
        </r-render>
      </r-part>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}

```
npm package: @rhtml/core
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.10

# @rhtml/core

#### Installation

```bash
npm i @rhtml/core
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';
import { BehaviorSubject } from 'rxjs';
import { delay } from 'rxjs/operators';

import '@rhtml/core';

interface State { counter: number }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-renderer
        .options=${{
          state: new BehaviorSubject({ counter: 1 }).pipe(
            delay(1700),
          ),
          render: (
            res: State,
            setState: (res: State) => State
          ) =>
            html`
              <r-button
                palette="danger"
                @click=${() => setState({ counter: res.counter + res.counter })}
                >Increment</r-button
              >
              ${res.counter}
            `,
          loading: () => html`adadadad`,
          error: () => html`adadadadadada`
        }}
      ></r-renderer>

      <r-for .of=${['IterableItem 1', 'Iterable Item 2']}>
        <r-let .item=${v => html``}></r-let>
      </r-for>

      <r-part>
        <r-state .value=${this.select(res => res.data.randomName)}></r-state>
        <r-render .state=${name => html`
          <p>${name}</p>
        `}>
        </r-render>
      </r-part>

      <r-part>
        <r-settings .value=${{ fetchPolicy: 'cache-first' }}></r-settings>
        <r-fetch query="{
          continents {
            name
          }
        }"></r-fetch>
        <r-render .state=${({ data: { continents } }: IQueryData) => html`
          <r-for .of=${continents}>
            <r-let .item=${({ name }: IContinent) => name}></r-let>
          </r-for>
        `}>
        </r-render>
      </r-part>

      <r-part>
        <r-fetch subscribe="{ notifications { appUpdated } }"></r-fetch>
        <r-render .state=${({ data: { notifications: { appUpdated }}}) => html`
          <p>${appUpdated}</p>
        `}>
        </r-render>
      </r-part>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}

```
npm package: @rhtml/decorators
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/decorators

#### Installation

```bash
npm i @rhtml/decorators
```

#### Usage

```typescript
import { Attribute, Options, Input } from '@rhtml/custom-attributes';
import { HostListener } from '@rhtml/decorators';

@Modifier({
  selector: 'test',
})
export class TestDirective extends Attribute {
  @Input()
  myProperty: string;

  @HostListener('mouseenter')
  enter(event: Event) {
    console.log('ENTER', this, event);
    console.log(this.myProperty);
  }

  @HostListener('mouseleave')
  leave(event: Event) {
    console.log('LEAVE', this, event);
    console.log(this.myProperty);
  }
}
```

```html
<div test myProperty="12312">111</div>
```

#### Usage inside @rxdi/lit-html

```typescript
import { Component, html, LitElement } from '@rxdi/lit-html';

import { HostListener } from '@rhtml/decorators';

/**
 * @customElement home-component
 */
@Component({
  selector: 'home-component',
  template(this) {
    return html` Home Component `;
  },
})
export class HomeComponent extends LitElement {
  @HostListener('mouseenter') onEnter() {
    console.log('Enter home');
  }

  @HostListener('mouseleave') onLeave() {
    console.log('Leave home');
  }
}
```

#### Add window event listener

```typescript
import { Component, html, LitElement } from '@rxdi/lit-html';

import { HostListener } from '@rhtml/decorators';

/**
 * @customElement home-component
 */
@Component({
  selector: 'home-component',
  template(this) {
    return html` Home Component `;
  },
})
export class HomeComponent extends LitElement {
  @HostListener('window:mouseenter')
  onEnter() {
    console.log('Enter home');
  }

  @HostListener('window:mouseleave')
  onLeave() {
    console.log('Leave home');
  }
}
```

#### @HostBinding and @Input decorators

Specifiyng Input and HostBinding decorator gives you an reactive ability to assign styles directly to input properties
This way by editing `padding`, `color` or `background` will reflect to the style associated with
By doing this we can skip `OnInit`, `OnDestroy`, `OnUpdate` manual assign inside hooks

```typescript
import { Attribute, Input, Modifier } from '@rhtml/custom-attributes';
import { HostBinding } from '@rhtml/decorators';

@Modifier({
  selector: 'layout',
})
export class CustomLayout extends Attribute {
  @Input({ observe: true })
  @HostBinding('style.padding')
  padding: string;

  @Input({ observe: true })
  @HostBinding('style.color')
  color: string;

  @Input({ observe: true })
  @HostBinding('style.background')
  background: string;
}
```
npm package: @rhtml/fastify
Description: Fastify module with decorators
Author: Kristiyan Tachev
Latest version: 0.0.30

# @rhtml/fastify

#### Installation

```bash
npm i @rhtml/fastify
```

#### Usage

```ts
import multipart from '@fastify/multipart';
import { Module } from '@rhtml/di';

import { FastifyModule } from '@rhtml/fastify';

@Module({
  imports: [
    FastifyModule.forRoot({
      logger: pino({
        level: 'debug',
      }),
      plugins: [
        {
          module: multipart,
        },
      ],
    }),
  ],
})
export class AppModule {}
```

#### Controller

```typescript
import { Controller, Route } from '@core';

@Controller({
  route: '/status',
})
export class HealthCheckController {
  @Route({
    method: 'GET',
  })
  healthCheck() {
    return {
      server: {
        status: 'working',
      },
    };
  }
}
```

#### AppModule

```typescript
import 'pino-pretty';

import { Module } from '@rhtml/di';
import pino from 'pino';

import { FastifyModule } from '@rhtml/fastify';

import { HealthCheckController } from './healtcheck.controller';

@Module({
  imports: [
    FastifyModule.forRoot({
      logger: pino({
        level: 'debug',
        transport: {
          target: 'pino-pretty',
          options: {
            colorize: true,
          },
        },
      }),
    }),
  ],
  bootstrap: [HealthCheckController],
})
export class AppModule {}
```

#### Importing external plugin to fastify rhtml module

```typescript
import 'pino-pretty';

import multipart from '@fastify/multipart';
import { Module } from '@rhtml/di';
import pino from 'pino';

import { FastifyModule } from '@rhtml/fastify';

import { HealthCheckController } from './healtcheck.controller';

@Module({
  imports: [
    FastifyModule.forRoot({
      logger: pino({
        level: 'debug',
        transport: {
          target: 'pino-pretty',
          options: {
            colorize: true,
          },
        },
      }),
      plugins: [
        {
          module: multipart,
          options: {},
        },
      ],
    }),
  ],
  bootstrap: [HealthCheckController],
})
export class AppModule {}
```
npm package: @rhtml/graphql
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/graphql

#### Installation

```bash
npm i @rhtml/graphql
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';
import { BehaviorSubject } from 'rxjs';
import { delay } from 'rxjs/operators';

import '@rhtml/components';
import '@rhtml/operators';
import '@rhtml/graphql';

interface State { counter: number }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-part>
        <r-settings .value=${{ fetchPolicy: 'cache-first' }}></r-settings>
        <r-fetch query="{
          continents {
            name
          }
        }"></r-fetch>
        <r-render .state=${({ data: { continents } }: IQueryData) => html`
          <r-for .of=${continents}>
            <r-let .item=${({ name }: IContinent) => name}></r-let>
          </r-for>
        `}>
        </r-render>
      </r-part>

      <r-part>
        <!-- <r-state .value=${interval(1000).pipe(map(i => ({ data: { notifications: { appUpdated: i } } })))}></r-state> -->
        <r-fetch .subscribe=${`{ notifications { appUpdated } }`}></r-fetch>
        <r-render .state=${(
            { data: { notifications: { appUpdated } }}: NotificationState,
            setState: (s: NotificationState) => void
          ) => html`
            <p>${appUpdated}</p>
            <button
              @click=${() => {
                setState({
                  data: {
                    notifications: {
                      appUpdated: Number(appUpdated) + Number(appUpdated)
                    }
                  }
                });
              }}
            >
              Increment Subscriptions State x2
            </button>
            (will be overriten when server emit new state)
          `}
        >
        </r-render>
      </r-part>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}

```
npm package: @rhtml/hooks
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/hooks

#### Installation

```bash
npm i @rhtml/hooks
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';
import { useState } from '@rhtml/hooks';

interface MonadState { myState: boolean }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-part>
        <r-state .value=${{ myState: false }}></r-state>
        <r-render .state=${(s, setMonadState: (s: MonadState) => void) => {
          const [state$, setState, getState] = useState({ myState2: false });
          const state = getState();
          return html`
            <p>${state.myState2}</p>
            <p>${s.myState}</p>
            <button @click=${() => setState({ myState2: true })}>setHookState</button>
            <button @click=${() => setMonadState({ myState: true })}>setMonadState</button>
          `
        }}>
        </r-render>
      </r-part>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}
```
npm package: @rhtml/modifiers
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/modifiers

#### Installation

```bash
npm i @rhtml/modifiers
```

Every modifier is actually `custom attribute` and modifiers is using package [@rhtml/custom-attributes](../custom-attributes)

#### Usage

Another real example is to add FlexLayout modifier from `@rhtml/modifiers` which will apply useful attributes
to be used inside of the html inspired from Angular flex-layout https://github.com/angular/flex-layout/wiki/Declarative-API-Overview

```typescript
import { Component, css, html, LitElement } from '@rxdi/lit-html';

import { FlexLayout } from '@rhtml/modifiers';

/**
 * @customElement home-component
 */
@Component({
  selector: 'home-component',
  style: css`
    .container {
      height: 200px;
    }

    .block {
      background: red;
      flex: 1;
    }
  `,
  modifiers: [...FlexLayout],
  template(this: HomeComponent) {
    return html`
      <div class="container" fxLayout="row" fxLayoutGap="10px">
        <div>
          <div class="block" fxLayoutAlign="center center" fxFlexFill>A</div>
        </div>
        <div>
          <div class="block" fxLayoutAlign="center center" fxFlexFill>B</div>
        </div>
        <div>
          <div class="block" fxLayoutAlign="center center" fxFlexFill>C</div>
        </div>
        <div>
          <div class="block" fxLayoutAlign="center center" fxFlexFill>D</div>
        </div>
      </div>
    `;
  }
})
export class HomeComponent extends LitElement {}
```

#### Angular Layout

`ngIf` attribute available at the moment to test the logic which represents

```typescript
import { Component, html, LitElement, state } from '@rxdi/lit-html';

import { AngularLayout } from '@rhtml/modifiers';

/**
 * @customElement home-component
 */
@Component({
  selector: 'home-component',
  modifiers: [...AngularLayout],
  template(this: HomeComponent) {
    return html`
      <div ngIf=${this.show}>
        My Content
      </div>

      <button @click=${() => this.toggle()}>Toggle</button>
    `;
  }
})
export class HomeComponent extends LitElement {
  @state()
  show: boolean;

  toggle() {
    this.show = !this.show;
  }
}
```

#### Animation modifier

List of available animations can be found [Here](./src/animation/interfaces.ts)

```typescript
import { Component, html, LitElement } from '@rxdi/lit-html';

import { Animation } from '@rhtml/modifiers';

/**
 * @customElement home-component
 */
@Component({
  selector: 'home-component',
  modifiers: [Animation],
  template(this: HomeComponent) {
    return html`
      <h2 animated="slideInLeft" delay="1s">
        Your Animated Element
      </h2>
    `;
  }
})
export class HomeComponent extends LitElement {}
```
npm package: @rhtml/mongoose
Description: Mongoose module wrapper
Author: Kristiyan Tachev
Latest version: 0.0.30

# @rhtml/mongoose

#### Installation

```bash
npm i @rhtml/mongoose
```

#### Usage

```ts
import { Module } from '@rhtml/di';
import mongoose from 'mongoose';

import { MongoDbModule } from './mongodb';

@Module({
  imports: [MongoDbModule.forRoot(mongoose, 'MONGODB_CONNECTION_STRING')],
})
export class CoreModule {}
```
npm package: @rhtml/operators
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/operators

#### Installation

```bash
npm i @rhtml/operators
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';

import '@rhtml/operators';

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-for .of=${['IterableItem 1', 'Iterable Item 2']}>
        <r-let .item=${v => html``}></r-let>
      </r-for>

      <r-let .data=${['IterableItem 1', 'Iterable Item 2']} .item=${v => html`
        dadada
      `}></r-let>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}

```
npm package: @rhtml/renderer
Description: Reactive HyperText Markup Language
Author: Kristiyan Tachev
Latest version: 0.0.146

# @rhtml/renderer

#### Installation

```bash
npm i @rhtml/renderer
```

#### Usage

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';

import '@rxdi/renderer';

interface State { counter: number; }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-renderer
        .options=${{
          state: { counter: 1 },
          render: (res: State, setState: (res: State) => State) =>
            html`
              <button
                @click=${() => setState({ counter: res.counter + res.counter })}
              >
                Increment
              </button>
              ${res.counter}
            `,
          loading: () =>
            html`
              Loading...
            `,
          error: () =>
            html`
              Error
            `
        }}
      ></r-renderer>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}
```


##### Can be provided also `observable` value

```typescript
import { LitElement, Component, html } from '@rxdi/lit-html';
import { BehaviorSubject } from 'rxjs';

import '@rxdi/renderer';

interface State { counter: number; }

@Component({
  selector: 'r-html-view',
  template(this: RHtmlViewComponent) {
    return html`
      <r-renderer
        .options=${{
          state: new BehaviorSubject({ counter: 1 }),
          render: (res: State, setState: (res: State) => State) =>
            html`
              <button
                @click=${() => setState({ counter: res.counter + res.counter })}
              >
                Increment
              </button>
              ${res.counter}
            `,
          loading: () =>
            html`
              Loading...
            `,
          error: () =>
            html`
              Error
            `
        }}
      ></r-renderer>
    `;
  }
})
export class RHtmlViewComponent extends LitElement {}
```
npm package: @rhumaric/data-proxy
Description: Template for NodeJS projects
Author: Romaric Pascal
Latest version: 0.3.0

data-proxy
===

An experiment to create a proxy over one or many Object that:

- reads the property from the first object with it
- allow computed properties.

Usage
---

```js
const {chainOfResponisibility, compute} = require('@rhumaric/data-proxy');

const proxy = chainOfResponsibility([
  {
    fileName: 'an/article--fr.md'
  },
  {
    defaultLocale: 'en',
    supportedLocales: compute(data => [data.defaultLocale, 'fr']),
    locale: compute(data => getLocale(data.fileName)),
  }
])
```

Possible future implementation
---

- [ ] Implement `has` handler
- [ ] Implement `set` handler (on first object with property, or on injected new object first of the list)
- [ ] Try out some memoisation?
- [ ] See if the concept could be genericised into some proxy builder
- [ ] Indexing of first source for each property

Possible other proxies usefulness
---
- [ ] caching of read values (nice for heavy computed operations, or values coming from deep down the source list). Bonus for uncaching when `set`ing. Extra bonus for uncaching computed properties (track which properties are accessed and use as a key for the cache? will there be a gain though, the key computation sound heavy?)
- [ ] `change` events when setting value. Bonus for only triggering when the value actually change. Other bonus for having a `willChange` that can be cancelled?
- [ ] JSON proxy: delay `require`ing of JSON until the values are actually needed
npm package: @rhumaric/postcss-functions
Description: PostCSS plugin for exposing JavaScript functions - Fork of andyjansson/postcss-functions
Author: Andy Jansson
Latest version: 3.0.0

# postcss-functions [![Build Status][ci-img]][ci]

[PostCSS] plugin for exposing JavaScript functions.

[PostCSS]: https://github.com/postcss/postcss
[ci-img]:  https://travis-ci.org/andyjansson/postcss-functions.svg
[ci]:      https://travis-ci.org/andyjansson/postcss-functions

## Installation

```js
npm install postcss-functions
```

## Usage

```js
var fs = require('fs');
var postcss = require('postcss');
var functions = require('postcss-functions');

var options = {
	//options
};

var css = fs.readFileSync('input.css', 'utf8');

postcss()
  .use(functions(options))
  .process(css)
  .then(function (result) {
    var output = result.css;
  });
```

**Example** of a function call:

```css
body {
	prop: foobar();
}
```

## Options

### `functions`

Type: `Object`

An object containing functions. The function name will correspond with the object key.

**Example:**

```js
var color = require('css-color-converter');
```

```js
require('postcss-functions')({
    functions: {
        darken: function (value, frac) {
           var darken = 1 - parseFloat(frac);
           var rgba = color(value).toRgbaArray();
           var r = rgba[0] * darken;
           var g = rgba[1] * darken;
           var b = rgba[2] * darken;
           return color([r,g,b]).toHexString();
        }
    }
});
```

```css
.foo {
    /* make 10% darker */
    color: darken(blue, 0.1);
}
```

### `glob`

Type: `string|string[]`

Loads files as functions based on one or more glob patterns. The function name will correspond with the file name.

**Example:**

```js
require('postcss-functions')({
	glob: path.join(__dirname, 'functions', '*.js')
});
```
### `withNode`

Type: `string[]`

A list of function names for which you'd like the CSS node to be provided as the first argument

**Example:**

```js
require('postcss-functions')({
  functions: {
    willGetTheNode: function(node, otherArg) {
      // Will receive the node as first argument
    },
    wontGetTheNode: function(arg) {
      // Won't receive it
    }
  },
  withNode: ['willGetTheNode']
});
```

### `walk`

Type: `function`

By default, the plugin walks all the nodes of the AST. You can use the `walk` option to provide your own walking function.

**Example:**

```js
require('postcss-functions')({
  // Only walk declarations of matching /background/
  walk: function (css, cb) {
    css.walkDecls(/background/,cb);
  }
});
```
npm package: @rhumbertgz/eslint-config-react
Description: Shared ESLint config for React projects
Author: Humberto Rodríguez Avila
Latest version: 0.0.3

# Shared ESLint configuration for React projects

This [ESLint](https://eslint.org/) configuration deactivates all formatting rules of ESLint and makes sure that [Prettier](https://prettier.io/) is used for code beautifying.

## Integrate into new project

1. Install this package as devDependency

```sh
# yarn
$ yarn add -D @rhumbertgz/eslint-config-react

# npm
$ npm i -D @rhumbertgz/eslint-config-react

# pnpm
$ pnpm add -D @rhumbertgz/eslint-config-react
```

2. Use ESLint config in your project

Create a `.eslintrc.js` file in project root with the following content:

```js
module.exports = {
  extends: ["@rhumbertgz/eslint-config-react"],
};
```
npm package: @rhumbertgz/prettier-config
Description: Shared Prettier config
Author: Humberto Rodríguez Avila
Latest version: 0.0.1

# Shared Prettier configuration

This shared [Prettier](https://prettier.io/) configuration changes some of the default behavior.

## Integrate into new project

1. Install this package as devDependency

```sh
# yarn
$ yarn add -D @rhumbertgz/prettier-config

# npm
$ npm i -D @rhumbertgz/prettier-config

# pnpm
$ pnpm add -D @rhumbertgz/prettier-config
```

2. Install peer dependencies of this package in your project as devDependencies

Therefore, you can make use of the tool [install-peerdeps](https://github.com/nathanhleung/install-peerdeps):

```sh
# yarn
$ yarn dlx install-peerdeps --dev @rhumbertgz/prettier-config

# npm
$ npx install-peerdeps --dev @rhumbertgz/prettier-config

# pnpm
$ pnpm dlx install-peerdeps --dev @rhumbertgz/prettier-config
```

3. Use Prettier config in your project

Create a `.prettierrc` file in project root with the following content:

```
"@rhumbertgz/prettier-config"
```
npm package: @rhurtado/demo-package
Description: Sample package: publishing first package
Author: Rodrigo hurtado
Latest version: 1.1.0

# Sample package: Node.js first package

This is a sample package to learn how to publish packages in npm.

## Installation
```bash
npm install @rhurtado/demo-package
```

## Usage
```js
import { sum, multiply } from '@rhurtado/demo-package';
console.log(sum(1,2));

console.log(multiply(5,2));
```
npm package: @rhymiz/simple-tasks
Description: Thin, function-based task framework on top of BullMQ for TypeScript.
Author: rhymiz
Latest version: 0.2.5

# simple-tasks

Function-based task framework on top of BullMQ. Define tasks with a single function, enqueue them easily, and run all workers from one entrypoint.

![NPM Version](https://img.shields.io/npm/v/@rhymiz/simple-tasks)


## Install

```bash
bun install @rhymiz/simple-tasks bullmq
```

Peer dependencies:
- bullmq (>=4 <6)

## Quick start

Define a task:

```ts
// src/queues/email.ts
import { defineTask } from '@rhymiz/simple-tasks';

type SendWelcomeData = { userId: string };

export const sendWelcomeEmail = defineTask<SendWelcomeData>({
  name: 'send-welcome-email',
  queuePrefix: 'emails',
  worker: { concurrency: 5 },
  defaultJobOptions: { attempts: 3 },
}, async (data, job) => {
  console.log('Sending welcome email to', data.userId, 'job', job.id);
});
```

Enqueue from anywhere:

```ts
await sendWelcomeEmail.enqueue({ userId: '123' });
await sendWelcomeEmail.enqueue({ userId: '123' }, { delay: 10_000 });
```

Worker entrypoint:

```ts
// src/queue-worker.ts
import './queues/email';
import './queues/billing';
import './queues/notifications';

import { runAllWorkers } from '@rhymiz/simple-tasks/runtime';

const onlyQueues = process.env.QUEUES?.split(',').filter(Boolean);
const onlyJobs = process.env.JOBS?.split(',').filter(Boolean);

runAllWorkers({ onlyQueues, onlyJobs });
```

## Configuration

The framework passes Redis connection options to BullMQ. Configure via environment variables:
- `REDIS_URL` (optional, takes precedence over host/port)
- `REDIS_HOST` (default: `127.0.0.1`)
- `REDIS_PORT` (default: `6379`)
- `SIMPLE_TASKS_QUEUE_PREFIX` (optional, prepends to every queue name with `-`)

BullMQ manages its own clients; this package does not import `ioredis` directly.

## Development

This package is built with TypeScript.

```bash
npm run build           # build JS and .d.ts into dist/
npm run lint            # run linter
npm run pack            # create tarball for testing
```

## Releasing

This project uses automated releases via GitHub Actions.

### Manual Release Process

1. **Bump version** (creates a git tag automatically):
   ```bash
   bun run version:patch   # 0.1.0 -> 0.1.1 (bug fixes)
   bun run version:minor   # 0.1.0 -> 0.2.0 (new features)
   bun run version:major   # 0.1.0 -> 1.0.0 (breaking changes)
   ```

2. **Push the tag** to trigger the release:
   ```bash
   git push --follow-tags
   ```

3. The GitHub Action will automatically:
   - Create a GitHub Release
   - Build the package
   - Publish to GitHub Package Registry

### Using the Package

To install from GitHub Packages, add to your `.npmrc`:
```
@rhymiz:registry=https://npm.pkg.github.com
```

Then install:
```bash
bun install @rhymiz/simple-tasks bullmq
```

## License

MIT
npm package: @rhynie/sdk
Description: 🛠 An SDK for building applications on top of Uniswap V2
Latest version: 3.0.3

# Uniswap V2 SDK

[![Unit Tests](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3ALint)
[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![npm version](https://img.shields.io/npm/v/@uniswap/v2-sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/v2-sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/v2-sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/v2-sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).
npm package: @rhynie/sdk-core
Description: ⚒️ An SDK for building applications on top of Uniswap V3
Latest version: 3.1.1

# Uniswap SDK Core

[![Unit Tests](https://github.com/Uniswap/uniswap-sdk-core/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-sdk-core/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-sdk-core/actions?query=workflow%3ALint)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk-core/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk-core/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk-core/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk-core@latest)

This code is shared across Uniswap TypeScript SDKs.
npm package: @rhynie/v2-sdk
Description: 🛠 An SDK for building applications on top of Uniswap V2
Latest version: 3.0.3

# Uniswap V2 SDK

[![Unit Tests](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Unit%20Tests/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3A%22Unit+Tests%22)
[![Lint](https://github.com/Uniswap/uniswap-v2-sdk/workflows/Lint/badge.svg)](https://github.com/Uniswap/uniswap-v2-sdk/actions?query=workflow%3ALint)
[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![npm version](https://img.shields.io/npm/v/@uniswap/v2-sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/v2-sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/v2-sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/v2-sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).
npm package: @rhyolite/cli
Description: Rhyolite CLI
Author: Edmo Lima
Latest version: 0.2.0


# @rhyolite/cli

Rhyolite CLI

## About

This package is the CLI for the Rhyolite monorepo. All command parsing and CLI logic lives here. The core package only provides business rules and utilities.

## Usage

### Create a plugin or theme

```sh
npm create rhyolite@latest my-plugin -- --plugin typescript-plugin
npm create rhyolite@latest my-theme -- --theme typescript-theme
```

The CLI will print:
- `plugin created` for plugins
- `theme created` for themes

### Local execution (after build)

```sh
node dist/index.js my-plugin -- --plugin typescript-plugin
node dist/index.js my-theme -- --theme typescript-theme
```

Or install globally:

```sh
pnpm build
pnpm link --global
rhyolite my-plugin -- --plugin typescript-plugin
```

## Scripts

- `pnpm build` — Compiles the CLI to dist/
- `pnpm lint` — Lints TypeScript files
- `pnpm format` — Formats the code
- `pnpm test` — Tests (placeholder)
- `pnpm clean` — Removes dist/

## Development

- Edit code in `src/`
- Run `pnpm build` to compile
- Run `pnpm lint` and `pnpm format` to keep code style

## Dependencies

- Uses the `@rhyolite/core` package from the monorepo

## License

MIT
npm package: @rhysforyou/gatsby-plugin-react-helmet-async
Description: Use React Helmet Async with your Gatsby site
Author: Rhys Powell
Latest version: 0.1.3

# gatsby-plugin-react-helmet-async

[![GitHub](https://img.shields.io/github/license/rhysforyou/gatsby-plugin-react-helmet-async.svg?style=flat-square)](https://github.com/rhysforyou/gatsby-plugin-react-helmet-async/blob/master/LICENSE) [![npm (scoped)](https://img.shields.io/npm/v/@rhysforyou/gatsby-plugin-react-helmet-async.svg?style=flat-square)](https://www.npmjs.com/package/@rhysforyou/gatsby-plugin-react-helmet-async)

Adds support for [React Helmet Async] to a Gatsby project.

[react helmet async]: (https://github.com/staylor/react-helmet-async)

## Installation

```sh
# Yarn
yarn add react-helmet-async @rhysforyou/gatsby-plugin-react-helmet-async

# npm
npm install --save react-helmet-async @rhysforyou/gatsby-plugin-react-helmet-async
```

## Usage

Add the plugin and its options to your `gatsby-config.js` like so:

```js
module.exports = {
  plugins: ["@rhysforyou/gatsby-plugin-react-helmet-async"]
};
```

Then just use React Helmet Async as you usually would, the plugin will create the `HelmetProvider` component for you and ensure that your `<head>` element contains the correct tags when building your site.
npm package: @rhysforyou/gatsby-plugin-safari-site-icon
Description: Add an SVG icon for Safari to your Gatsby site
Author: Rhys Powell
Latest version: 1.0.2

# gatsby-plugin-safari-site-icon

![GitHub](https://img.shields.io/github/license/rhysforyou/gatsby-plugin-safari-site-icon.svg?style=flat-square) ![npm (scoped)](https://img.shields.io/npm/v/@rhysforyou/gatsby-plugin-safari-site-icon.svg?style=flat-square)

Adds support for shipping a Safari site icon with your site. Safari site icons
are monochrome, SVG icons which safari uses in place of favicons where provided.

[This section of Apple's developer documentation][docs] gives a good overview of
the subject, though it's worth noting these icons are now used in many other
cases than just pinned sites nowadays.

[docs]: https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/pinnedTabs/pinnedTabs.html

## Installation

```sh
# Yarn
yarn add @rhysforyou/gatsby-plugin-safari-site-icon

# npm
npm install --save @rhysforyou/gatsby-plugin-safari-site-icon
```

## Usage

Add the plugin and its options to your `gatsby-config.js` like so:

```js
module.exports = {
  plugins: [
    {
      resolve: "@rhysforyou/gatsby-plugin-safari-site-icon",
      options: {
        icon: "./src/images/pinned-tab-icon.svg",
        color: "#FF374B"
      }
    }
  ]
};
```

### Options

| Name    | Required | Description                                      |
| :------ | :------- | :----------------------------------------------- |
| `icon`  | ✅       | The path to your icon, relative to the site root |
| `color` | ❌       | The color your icon should be tinted with        |
npm package: @rhysforyou/react-native-carousel
Description: This package provides a simple, performant carousel component for React Native apps, with no native dependencies.
Author: Rhys Powell
Latest version: 0.1.1

# React Native Carousel

This package provides a simple, performant carousel component for React Native apps, with no native dependencies.

![A demo of the library in action](https://raw.githubusercontent.com/rhysforyou/react-native-horizontal-carousel/master/demo.gif)

[View this demo in Expo](https://snack.expo.io/SklK-ARM4)

## Installation

With Yarn

```sh
yarn add @rhysforyou/react-native-carousel
```

With npm:

```
npm install --save @rhysforyou/react-native-carousel
```

## Usage

If you've ever used React Native's `FlatList` component, you'll be right at home:

```jsx
<Carousel
  data={[
    {
      id: "1",
      title: "Carousel",
      description: "A handy component for React Native"
    }
    // ...
  ]}
  renderItem={info => (
    <View>
      <Text style={styles.title}>{info.item.title}</Text>
      <Text style={styles.description}>{info.item.description}</Text>
    </View>
  )}
  keyExtractor={item => item.id}
/>
```

## API

### Props

- [`style`](#style)
- [`data`](#data)
- [`renderItem`](#renderItem)
- [`keyExtractor`](#keyExtractor)

---

#### `style`

A set of styles to apply to the underlying `FlatList` component.

| Type                                                                         | Required |
| :--------------------------------------------------------------------------- | :------- |
| [view styles](https://facebook.github.io/react-native/docs/view-style-props) | false    |

#### `data`

A plain array of data items to be rendered by the carousel.

| Type  | Required |
| :---- | :------- |
| array | true     |

#### `renderItem`

```js
renderItem({ item: Object, index: number, separators: { highlight: Function, unhighlight: Function, updateProps: Function(select: string, newProps: Object) } }) => ?React.Element
```

Takes an item from `data` and renders it into the carousel, wrapping it in a card view of fixed width.

For more information see the [`FlatList` docs](https://facebook.github.io/react-native/docs/flatlist#renderitem).

| Type     | Required |
| :------- | :------- |
| function | true     |

#### `keyExtractor`

```js
keyExtractor(item: Object, index: number) => string
```

Takes an item from `data` and its `index` and returns a unique key.

| Type     | Required |
| :------- | :------- |
| function | true     |
npm package: @rhyslbw/swagger-to-graphql
Description: Swagger2GraphQL converts your existing Swagger schema to GraphQL types where resolvers perform HTTP calls to certain real endpoints. It allows you to move your API to GraphQL with nearly zero effort and maintain both REST and GraphQL APIs.
Author: Roman Krivtsov
Latest version: 0.1.2

# Swagger2GraphQL

Swagger2GraphQL converts your existing Swagger schema to GraphQL types where resolvers perform HTTP calls to certain real endpoints.
It allows you to move your API to GraphQL with nearly zero effort and maintain both REST and GraphQL APIs.

<a href="https://medium.com/@raxwunter/moving-existing-api-from-rest-to-graphql-205bab22c184">Why?</a>

# Usage

## Basic server

```js
const express = require('express');
const app = express();
const graphqlHTTP = require('express-graphql');
const graphQLSchema = require('swagger-to-graphql');
const fs = require('fs');

const proxyUrl = 'http://petstore.swagger.io/v2';
const pathToSwaggerSchema = './petstore.json';
const options = {
  customHeaders: {
  // Authorization: 'Basic YWRkOmJhc2ljQXV0aA=='
  }
  agentOptions: {
    ca: fs.readFileSync('ca.crt'),
    key: fs.readFileSync('client.key'),
    cert: fs.readFileSync('cert.pem')
  }
}

graphQLSchema(pathToSwaggerSchema, proxyUrl, options).then(schema => {
  app.use('/graphql', graphqlHTTP(() => {
    return {
      schema,
      graphiql: true
    };
  }));

  app.listen(3009, 'localhost', () => {
    console.info('http://localhost:3009/graphql');
  });
}).catch(e => {
  console.log(e);
});
```

Constructor (graphQLSchema) arguments:
* `pathToSwaggerSchema` (string) is a path to your local swagger schema file. *required*
* `proxyUrl` (string) base URL which will be used to hit your HTTP API. Can be taken either from Swagger schema `baseUrl` configuration or from this parameter.
* `options` (object)
  - `customHeaders` (object) key value object of custom headers, which should be included to the HTTP request. Can be used for example for authorization (look at the example above)
  - `agentOptions` (object) Currently limited to support client certificate authentication.

## CLI usage

You can use the library just to convert schemas without actually running server

```
npm i -g swagger-to-graphql
swagger-to-graphql --swagger=/path/to/swagger_schema.json > ./types.graphql
```
npm package: @rhyster/eslint-config
Description: ESLint config
Author: Rhythm
Latest version: 2.0.5

# @rhyster/eslint-config

ESLint config inspired by [eslint-config-airbnb](https://github.com/airbnb/javascript) and [eslint-config-airbnb-typescript](https://github.com/iamturns/eslint-config-airbnb-typescript).

## License

MIT License
npm package: @rhyster/wow-casc-dbc
Description: Fetch World of Warcraft data files from CASC and parse DBC/DB2 files.
Author: Rhythm
Latest version: 2.13.0

# WoW CASC & DBC

Node.js tool to fetch World of Warcraft data files from CASC and parse DBC/DB2 files.

## Snippet

### Basic Usage

```javascript
import { CASCClient, WDCReader, DBDParser } from '@rhyster/wow-casc-dbc';

// Get version
const region = 'us';
const product = 'wow';
const version = await CASCClient.getProductVersion(region, product);

// Client initialization
const client = new CASCClient(region, product, version);
await client.init();
await client.loadRemoteTACTKeys();
await client.loadRemoteListFile(); // pretty slow, recommend to provide fileDataID directly

// Fetch file
const fileDataID = client.getFileDataIDByName('dbfilesclient/questxp.db2'); // see previous line
const cKeys = client.getContentKeysByFileDataID(fileDataID);
const cKey = cKeys.find((data) => !!(data.localeFlags & CASCClient.LocaleFlags.enUS));
const { buffer } = await client.getFileByContentKey(cKey.cKey);

// Parse DB2 file
const reader = new WDCReader(buffer);
const parser = await DBDParser.parse(reader);

// Access DB2 file
reader.getAllIDs().forEach((id) => {
    const rowFields = reader.getRowData(id);
});
parser.getAllIDs().forEach((id) => {
    const rowObject = parser.getRowData(id);
});
```

### Partial Decrypt

Some file is encrypted and no key released yet. For DB2 files, you can ignore the encrypted part and parse the others.

```javascript
// ...

const result = await client.getFileByContentKey(cKey.cKey, true);
const reader = new WDCReader(result.buffer, result.blocks);
const parser = await DBDParser.parse(reader);

// ...
```

If you download DB2 files from wago.tools, you need to set `detectIsZeroedByData` to let `WDCReader` detect the undecrypted blocks and ignore them.

```javascript
// ...

const file = await fs.readFile('/path/to/db2/file.db2');
const reader = new WDCReader(file, { detectIsZeroedByData: true });
const parser = await DBDParser.parse(reader);

// ...
```

### Hotfix

Applying hotfix requires `DBCache.bin` file from the client, and it seems the only way to get this is from the client. So, you need to search for `DBCache.bin` yourself, like `<WoWPath>/_retail_/Cache/ADB/enUS/DBCache.bin` or download it somewhere.

It's also important to compare build, region and locale with the db2 file that to be patched to avoid broken data.

```javascript
// ...

const dbcache = await fs.readFile('path/to/DBCache.bin');
const buffer = await fs.readFile('path/to/name.db2');

const adb = new ADBReader(dbcache);
assert(adb.build === parseInt(version.BuildId, 10));

const reader = new WDCReader(buffer, [], adb);
const parser = await DBDParser.parse(reader);

// ...
```

## License

MIT License
npm package: @rhyswfbowles/pino-webpack-plugin
Description: A pino plugin for webpack
Author: Paolo Insogna
Latest version: 1.2.0

# pino-webpack-plugin

## Why have we created this fork?
Currently, we're in a bit of a messy situation where lambdas require one webpack version to function, but this package is pulling us up to a different version which is causing it to fail.
We cannot use package.json resolutions as storybook currently does not support webpack 5.0 until their 7.0 release as per this issue https://github.com/storybookjs/storybook/issues/17436



[![Package Version](https://img.shields.io/npm/v/pino-webpack-plugin.svg)](https://npm.im/pino-webpack-plugin)
[![Dependency Status](https://img.shields.io/librariesio/release/npm/pino-webpack-plugin)](https://libraries.io/npm/pino-webpack-plugin)
[![Build](https://github.com/pinojs/pino-webpack-plugin/workflows/CI/badge.svg)](https://github.com/pinojs/pino-webpack-plugin/actions?query=workflow%3ACI)

A pino plugin for webpack.

## Installation

Just run:

```bash
npm install pino-webpack-plugin
```

## Description

This plugin allows to use of pino v7 with webpack generated bundle files.

Note that, due to pino architecture (based on Node.js' Worker Threads), it is not possible to make it work _without_ generating extra files.

This means that when using this plugin the following list of files will be generated at the root of your dist folder:

- `thread-stream.js`
- `pino-worker.js`
- `pino-pipeline-worker.js`
- `pino-file.js`
- A file for each transport you specify in the plugin constructor's `transports` option. (see below)

Each of the additional file is a bundle and therefore does not contain any external dependency, but it is needed to use pino and it must be included in the deployment.

## Usage

Simply include the plugin in your webpack configuration.
Make sure you provide the plugin a list of all the pino transports you use via the `transports` option (`pino/file` is always included so no need to specify it).

```js
const { PinoWebpackPlugin } = require('pino-webpack-plugin')

module.exports = {
  entry: 'index.js',
  plugins: [new PinoWebpackPlugin({ transports: ['pino-pretty'] })]
}
```

## Contributing

See [CONTRIBUTING.md](./CONTRIBUTING.md)

## License

Copyright Paolo Insogna and pino-webpack-plugin contributors 2021. Licensed under the [MIT License](http://www.apache.org/licenses/MIT).