open-index/open-npm huggingface dataset:
npm package: @nx-extend/playwright
Description: > [!IMPORTANT] > This package is no longer maintained in favor of @nx/playwright
Latest version: 12.1.1

> [!IMPORTANT]
> This package is no longer maintained in favor of @nx/playwright

# @nx-extend/playwright

<a href="https://www.npmjs.com/package/@nx-extend/playwright" rel="nofollow">
  <img src="https://badgen.net/npm/v/@nx-extend/playwright" alt="@nx-extend/playwright NPM package">
</a>

**Nx plugin for adding [Playwright](https://playwright.dev/) to your app**.

## Features

- Add Playwright E2E testing to your Nx workspace
- Integration with @nx-extend/e2e-runner for automated setup
- Support for starting services before tests

## Setup

### Install

```sh
npm install -D @nx-extend/playwright
nx g @nx-extend/playwright:init
```

## Usage

When running `nx e2e <your-project>` it will directly start Playwright. If you need to build/serve your app first, update your project targets to the following:

```json
{
  "targets": {
    "e2e": {
      "executor": "@nx-extend/e2e-runner:run",
      "options": {
        "runner": "playwright",
        "targets": [
          {
            "target": "<target to start your app>",
            "checkUrl": "<url the target will come online on>"
          }
        ]
      }
    }
  }
}
```

## Migration

This package is deprecated. Please migrate to [@nx/playwright](https://nx.dev/packages/playwright) for continued support and updates.
npm package: @nx-extend/react-email
Description: <a href="https://www.npmjs.com/package/@nx-extend/react-email" rel="nofollow">   <img src="https://badgen.net/npm/v/@nx-extend/react-email" alt="@nx-extend/react-email NPM package"> </a>
Latest version: 6.1.1

# @nx-extend/react-email

<a href="https://www.npmjs.com/package/@nx-extend/react-email" rel="nofollow">
  <img src="https://badgen.net/npm/v/@nx-extend/react-email" alt="@nx-extend/react-email NPM package">
</a>

**Nx plugin for building emails with [React Email](https://react.email)**.

## Features

- Build and preview emails using React components
- Live development server for email templates
- Export emails to static HTML
- Full TypeScript support
- Integration with Nx workspace

## Setup

### Install

```sh
npm install -D @nx-extend/react-email
nx g @nx-extend/react-email:init
```

## Usage

### Serve

Start the React Email development server to preview your email templates:

```sh
nx serve <project-name>
```

#### Available options:

| Name       | Type     | Default | Description                           |
|------------|----------|---------|---------------------------------------|
| **`port`** | `string` | -       | Port to run the development server on |

### Export

Export your email templates to static HTML files:

```sh
nx export <project-name>
```

#### Available options:

| Name              | Type     | Default | Description                        |
|-------------------|----------|---------|------------------------------------|
| **`outputPath`**  | `string` | -       | Output path to output the build to |

## Examples

### Start Development Server

```sh
nx serve my-emails --port=3000
```

### Export Email Templates

```sh
nx export my-emails --outputPath=dist/emails
```

## Project Structure

After initialization, your project will typically have the following structure:

```
my-emails/
├── src/
│   └── emails/
│       └── welcome.tsx
└── project.json
```

Create email components in the `src/emails` directory using React Email components.
npm package: @nx-extend/shadcn-ui
Description: <a href="https://www.npmjs.com/package/@nx-extend/shadcn-ui" rel="nofollow">   <img src="https://badgen.net/npm/v/@nx-extend/shadcn-ui" alt="@nx-extend/shadcn-ui NPM package"> </a>
Latest version: 6.2.1

# @nx-extend/shadcn-ui

<a href="https://www.npmjs.com/package/@nx-extend/shadcn-ui" rel="nofollow">
  <img src="https://badgen.net/npm/v/@nx-extend/shadcn-ui" alt="@nx-extend/shadcn-ui NPM package">
</a>

**Nx plugin for working with [shadcn/ui](https://ui.shadcn.com/)**.

## Features

- Add shadcn/ui components to your Nx workspace
- Automatic setup of UI library and utilities
- Tailwind CSS integration
- Theme customization support
- Add individual or all components at once

## Setup

### Install

```sh
npm install -D @nx-extend/shadcn-ui
nx g @nx-extend/shadcn-ui:init
```

### Configure Tailwind

After installation, update your app's `tailwind.config.ts` to:

```ts
import { buildConfig } from '../libs/<lib directory>/src/tailwind.config'

export default buildConfig(__dirname)
```

### Remix Integration

If you are using Remix, you can import `global.css` directly:

```tsx
import stylesheet from '@<scope>/<utils lib name>/global.css'

export const links: LinksFunction = () => [
  { rel: 'stylesheet', href: stylesheet }
]
```

## Usage

### Add Component

Add a single component to your UI library:

```sh
nx add-component <ui lib name> button
```

### Add All Components

Add all available shadcn/ui components:

```sh
nx add-component <ui lib name>
```

## Updating the Theme

The generated `global.css` uses the default shadcn/ui theme. Using the shadcn/ui theme editor, you can effortlessly apply a different theme.

Explore available themes here: https://ui.shadcn.com/themes

## Available Components

shadcn/ui provides a wide range of beautifully designed components including:
- Buttons, inputs, and forms
- Cards, dialogs, and modals
- Dropdowns and menus
- Navigation components
- Data tables
- And many more

Visit https://ui.shadcn.com/docs/components for the full list of available components.
npm package: @nx-extend/vercel
Description: <a href="https://www.npmjs.com/package/@nx-extend/vercel" rel="nofollow">   <img src="https://badgen.net/npm/v/@nx-extend/vercel" alt="@nx-extend/vercel NPM package"> </a>
Latest version: 16.2.1

# @nx-extend/vercel

<a href="https://www.npmjs.com/package/@nx-extend/vercel" rel="nofollow">
  <img src="https://badgen.net/npm/v/@nx-extend/vercel" alt="@nx-extend/vercel NPM package">
</a>

**Nx plugin to deploy your app to [Vercel](https://vercel.com)**.

## Features

- Build Vercel projects from Nx workspace
- Deploy to Vercel with full configuration
- Support for project and organization IDs
- Debug mode for troubleshooting

## Setup

### Install

```sh
npm install -D @nx-extend/vercel
```

## Usage

### Build

Build your application for Vercel:

```sh
nx build <project-name>
```

#### Available Options

| Name              | Type      | Default | Description               |
|-------------------|-----------|---------|---------------------------|
| **`projectId`**   | `string`  | -       | Project ID of Vercel      |
| **`orgId`**       | `string`  | -       | Organisation ID of Vercel |
| **`debug`**       | `boolean` | `false` | Run Vercel in debug mode  |

### Deploy

Deploy your application to Vercel:

```sh
nx deploy <project-name>
```

#### Available Options

| Name          | Type      | Default | Description              |
|---------------|-----------|---------|--------------------------|
| **`debug`**   | `boolean` | `false` | Run Vercel in debug mode |

## How to Create a Vercel Project Through the CLI

To create a new Vercel project, run the following commands:

```sh
# Make sure you are in the right org
npx vercel teams list

# If needed, switch to correct team
npx vercel teams switch <team-id>

# Create the project
npx vercel project add <my-project>

# Go to the Vercel dashboard, <my-project> > settings > Project ID
```

## Examples

### Build with Project Configuration

```json
{
  "build": {
    "executor": "@nx-extend/vercel:build",
    "options": {
      "projectId": "prj_abc123xyz",
      "orgId": "team_abc123xyz"
    }
  }
}
```

### Deploy with Debug Mode

```json
{
  "deploy": {
    "executor": "@nx-extend/vercel:deploy",
    "options": {
      "debug": true
    }
  }
}
```
npm package: @nx-gems/express-app
Description: Nx generator for Express applications
Author: Naresh Bhatia
Latest version: 0.0.2

# express-app

Generator for Express applications and APIs.
This library was generated with [Nx](https://nx.dev).

## Getting started

Install this plugin in your existing nx repo.

```sh
npm install --save-dev @nx-gems/express-app
```

Run the plugin to generate an api

```sh
nx g @nx-gems/express-app:express-app test-api
```

This will create an express app at `/apps/test-api` with a example route of `/accounts`.

Execute the following command to run the express app:

```sh
nx serve test-api
```

Now point your browser to http://localhost:33333/accounts to test the example route.

## Running unit tests

Run `nx test express-app` to execute the unit tests via [Jest](https://jestjs.io).
npm package: @nx-go/dep-graph
Description: This library was generated with [Nx](https://nx.dev).
Latest version: 0.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# dep-graph

This library was generated with [Nx](https://nx.dev).

## Running unit tests

Run `nx test dep-graph` to execute the unit tests via [Jest](https://jestjs.io).
npm package: @nx-golang/gin
Description: nx-golang/gin is an opinionated  gin setup which uses [Uber fx](https://github.com/uber-go/fx) and [Swaggo](https://github.com/swaggo/swag)
Author: Di Zou
Latest version: 0.7.0

nx-golang/gin is an opinionated  gin setup which uses [Uber fx](https://github.com/uber-go/fx) and [Swaggo](https://github.com/swaggo/swag)

- It makes golang/gin code possible in nx repo.
- It makes your controllers/middlewares/routes/servies/repositories code consistent.
- It uses dependency injection.
- It supports auto generated OpenAPI doc from source.

## Setting Up @nx-golang/gin

To create a new workspace with @nx-golang/gin, run the following command:

```shell
npx create-nx-workspace my-workspace
```

Yarn users can use the following command instead:

```shell
yarn create nx-workspace my-workspace
```

To add the @nx-golang/gin plugin to an existing workspace, run one the following commands:

```shell
npm install -D @nx-golang/gin
```

```shell
yarn add -D @nx-golang/gin
```

### Create Applications

You can add a new @nx-golang/gin application with the following command:

```shell
nx g @nx-golang/gin:app gin-app
```

### Create Controllers/Middlewares/Services (TBD)
<!-- 
You can add a new @nx-golang/gin library with the following command:

```shell
nx g @nx-golang/gin:lib gin-lib
```

To make the library `buildable`, use the following command:

```shell
nx g @nx-golang/gin:lib gin-lib --buildable
```

To make the library `publishable`, use the following command:

```shell
nx g @nx-golang/gin:lib gin-lib --publishable --importPath=@my-workspace/gin-lib
```

> Read more about [building and publishing libraries here](/more-concepts/buildable-and-publishable-libraries). -->

## Using @nx-golang/gin

### Build

You can build an application with the following command:

```shell
nx build gin-app
```

### Serve (TBD)

You can serve an application with the following command:

```shell
nx serve gin-app
```
<!-- 

The `serve` command runs the `build` target, and executes the application.

By default, the serve command will run in `watch` mode. This allows code to be changed, and the @nx-golang/gin application to be rebuilt automatically. -->

#### Debugging (TBD)
<!-- 
@nx-golang/gin applications also have the `inspect` flag set, so you can attach your debugger to the running instance.

Debugging is set to use a random port that is available on the system. The port can be changed by setting the port option in the `serve` target in the `project.json`. Or by running the serve command with `--port <number>`.

For additional information on how to debug Node applications, see the [Node.js debugging getting started guide](https://nodejs.org/en/docs/guides/debugging-getting-started/#inspector-clients). -->

### Lint

You can lint an application with the following command:

```shell
nx lint gin-app
```

### Unit Test

You can run unit test for an application with the following command:

```shell
nx test gin-app
```

You can run unit test for a library with the following command:

```shell
nx test gin-lib
```

## More Documentation

TBD
npm package: @nx-helpers/nx-remote-cache-redis
Description: This is a task runner for @nrwl/nx https://nx.dev/react which uses a redis database as a remote caching storage. Read more about the benefits in the nx documentations [https://nx.dev/using-nx/caching#computation-caching]
Author: dk
Latest version: 1.0.0

# nx-remotecache-redis

This is a task runner for @nrwl/nx https://nx.dev/react which uses a redis database as a remote caching storage. Read more about the benefits in the nx documentations [https://nx.dev/using-nx/caching#computation-caching]

This package was built with [nx-remotecache-custom](https://www.npmjs.com/package/nx-remotecache-custom) 🔥

## Setup

```
npm install -D @nx-helpers/nx-remote-cache-redis
```

| Parameter    | Description                                                                         | Environment Variable    | nx.json  |
| ------------ | ----------------------------------------------------------------------------------- | ----------------------- | -------- |
| Redis URL    | The url to connect to redis for example: `redis://<user>:<password>@127.0.0.1:6379` | `NX_CACHE_REDIS_URL`    | `url`    |
| Redis Expire | Expire time in seconds to automaticaly delete keys                                  | `NX_CACHE_REDIS_EXPIRE` | `expire` |

```json
{
  "tasksRunnerOptions": {
    "default": {
      "runner": "@nx-helpers/nx-remote-cache-redis",
      "options": {
        // All of the redis specific options can also be inserted via environment variables!
        "url": "redis://127.0.0.1:6379",
        "cacheableOperations": ["build", "test", "lint", "e2e"]
      }
    }
  }
}
```
npm package: @nx-iac/aws-cdk
Description: Empowers your Nx workspace with AWS CDK capabilities ⚡
Author: Joel Klint
Latest version: 0.1.1

# @nx-iac/aws-cdk

Empowers your [Nx](https://nx.dev) workspace with [AWS CDK](https://aws.amazon.com/cdk/) capabilities ⚡

What does it do?

- Generate AWS CDK projects
- Deploy AWS CDK projects
- Gives you total control of CLI arguments through `project.json`

## Table of contents

- [Install](#install)
  - [Dependencies](#dependencies)
- [Usage](#usage)
  - [Bootstrap AWS environment](#bootstrap-aws-environment)
  - [Generate AWS CDK project](#generate-aws-cdk-project)
    - [New application](#new-application)
    - [Preexisting application](#preexisting-application)
  - [Package application](#package-application)
  - [Deploy application](#deploy-application)
  - [Deploy application quickly](#deploy-application-quickly)
  - [Destroy application](#destroy-application)
- [Maintainer](#maintainer)
- [Thanks](#thanks)
- [Contributing](#contributing)
- [License](#license)

## Install

```sh
# npm
npm install --save-dev @nx-iac/aws-cdk

# yarn
yarn add --dev @nx-iac/aws-cdk

# pnpm
pnpm install --save-dev @nx-iac/aws-cdk
```

### Dependencies

The machine utilising this plugin must be authenticated with AWS. Read more about how authentication works [here](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_auth)

## Usage

### Bootstrap AWS environment

Prepare AWS environment for AWS CDK

```sh
nx g @nx-iac/aws-cdk:bootstrap
```

### Generate AWS CDK project

#### New application

Create a new application in your Nx workspace, with AWS CDK capabilities

```sh
nx g @nx-iac/aws-cdk:app
```

#### Preexisting application

Give AWS CDK capabilities to a preexisting project in your Nx workspace

```sh
nx g @nx-iac/aws-cdk:appify
```

### Package application

Create deployment artifacts for your AWS CDK project

⚠️ Beware of caching this output, since a target AWS environment could be encoded in it

```sh
nx package <app-name>
```

```sh
nx package <app-name> --context key1=value1 --contextSome key2=value2
```

### Deploy application

Deploy your AWS CDK project, creating cloud resources in AWS

```sh
nx deploy <app-name>
```

### Deploy application quickly

Deploy your AWS CDK project in the quickest way possible, shortening the feedback cycle during development

```sh
# once
nx run <app-name>:deploy:quick

# in watch mode
nx watch --includeDependentProjects --projects=<app-name> -- nx run <app-name>:deploy:quick
```

### Destroy application

Destroy your AWS CDK project, deleting cloud resources in AWS

```sh
nx destroy <app-name>
```

## Maintainer

[@joelklint](https://github.com/joelklint)

## Thanks

This plugin is inspired by [@adrian-goe](https://github.com/adrian-goe)'s
[nx-aws-cdk-v2](https://github.com/adrian-goe/nx-aws-cdk-v2).

## Contributing

Read [CONTRIBUTING.md](/CONTRIBUTING.md)!

## License

[MIT © Joel Klint](/LICENSE)
npm package: @nx-js/animate-middleware
Description: An NX animation middleware, based on standrad CSS animations.
Author: Miklos Bertalan
Latest version: 1.0.1

# The animate middleware

The `animate` middleware allows you to create entering, leaving and moving animations with a few custom attributes.

- name: animate
- direct middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- type: component or content middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/animate)

## Installation

`npm install @nx-js/animate-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const animate = require('@nx-js/animate-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .useOnContent(animate)
  .register('animated-comp')
```

```html
<animated-comp @if="show">
  <span enter-animation="fadeIn 1s">Hello World!</span>
</animated-comp>
```
npm package: @nx-js/attributes-middleware
Description: An NX middleware, responsible for handling reactive and custom attributes.
Author: Miklos Bertalan
Latest version: 1.1.0

# The attributes middleware

The `attributes` middleware extends native attributes with dynamic behavior and provides a way to add custom attributes.

- name: attributes
- direct middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- type: component or content middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/attributes)

## Installation

`npm install @nx-js/attributes-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .register('attributes-comp')
```

```html
<attributes-comp>
  <span @hidden="!show">Hello World!</span>
</animated-comp>
```
npm package: @nx-js/bind-middleware
Description: An NX data-binding middlware.
Author: Miklos Bertalan
Latest version: 1.0.0

# The bind middleware

The `bind` middleware makes the `input`, `select` and `textarea` elements bindable with the `bind` custom attribute.

- name: bind
- middleware dependencies: [bindable](https://github.com/nx-js/bindable-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware), [bindable](https://github.com/nx-js/bindable-middleware)
- processes: element nodes
- throws on: nothing
- use as: component or content middleware
- [docs](http://nx-framework/docs/middlewares/bind)

## Installation

`npm install @nx-js/bind-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const bindable = require('@nx-js/bindable-middleware')
const bind = require('@nx-js/bind-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .useOnContent(bindable)
  .useOnContent(bind)
  .register('binding-comp')
```

```html
<binding-comp>
  <input type="number" name="age" bind />
</binding-comp>
```
npm package: @nx-js/bindable-middleware
Description: An NX middleware, responsible for data-binding.
Author: Miklos Bertalan
Latest version: 1.0.2

# The bindable middleware

The `bindable` middleware adds the `$bindable` method to elements, which can be used to make any element bindable.

- name: bindable
- middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- type: component or content middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/bind)

## Installation

`npm install @nx-js/bindable-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const style = require('@nx-js/bindable-middleware')

component()
  .use(observe)
  .use(attributes)
  .use(bindables)
  .use(elem => elem.$bindable({mode: 'two-way', on: 'input'}))
  .register('bindable-comp')
```

```html
<bindable-comp name="prop" bind></bindable-comp>
```
npm package: @nx-js/core
Description: A Web Components based NX core.
Author: Miklos Bertalan
Latest version: 1.1.0

# The core

The `core` is a [Web Components](https://developers.google.com/web/fundamentals/getting-started/primers/customelements) based core for the NX framework. You can learn more in [the Docs](http://nx-framework.com/docs).

## Installation

`npm install @nx-js/core`

## Usage

```js
const component = require('@nx-js/core')

component()
  .register('my-comp')
```

```html
<my-comp></my-comp>
```
npm package: @nx-js/events-middleware
Description: An NX middleware, responsible for inline event handling.
Author: Miklos Bertalan
Latest version: 1.0.0

# The events middleware

The `events` middleware allows you to use inline event handler attributes in the HTML view.

- name: events
- middleware dependencies: none
- all middleware dependencies: none
- processes: element nodes
- throws on: nothing
- use as: component or content middleware
- [docs](http://nx-framework/docs/middlewares/events)

## Installation

`npm install @nx-js/events-middleware`

## Usage

```js
const component = require('@nx-js/core')
const events = require('@nx-js/events-middleware')

component()
  .useOnContent(events)
  .register('events-comp')
```

```html
<events-comp>
  <button #click="alert('Hello World!')">Click me</button>
</events-comp>
```
npm package: @nx-js/filters
Description: Filters for the NX compiler util.
Author: Miklos Bertalan
Latest version: 1.0.0

# Filters

This repository contains a collection of filters for the
[compiler utility](https://github.com/nx-js/compiler-util). It creates an registers the
following filters.

- capitalize: Capitalizes the passed string.
- lowercase: Transforms the passed string to a lower case format.
- uppercase: Transforms the passed string to an uppercase format.
- unit: Has a value and a unit name parameter. Appends the unit name after the value and pluralizes the unit if the value is plural.
- slice: Has two number parameters. Slices the value from the first to the second parameter.
- json: Converts the passed value to JSON. The indentation level can be passed as an argument.
- date: Converts the passed date to a local date string.
- time: Converts the passed date to a local time string.
- datetime: Converts the passed date to a local datetime string.

You can learn more
about NX filters [here](http://nx-framework/docs/middlewares/interpolate).
npm package: @nx-js/flow-middleware
Description: An NX middleware, responsible for handling loops and conditionals in the view.
Author: Miklos Bertalan
Latest version: 1.0.1

# The flow middleware

The `flow` middleware is responsible for controlling visual flow in the HTML view.

- name: flow
- middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- type: component or content middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/flow)

## Installation

`npm install @nx-js/flow-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const flow = require('@nx-js/flow-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .useOnContent(flow)
  .register('flow-comp')
```

```html
<flow-comp @repeat="names" repeat-value="name">
  <p>The name is ${name}</p>
</flow-comp>
```
npm package: @nx-js/interpolate-middleware
Description: An NX middleware, responsible for dynamic and one-time text interpolation.
Author: Miklos Bertalan
Latest version: 1.0.1

# The interpolate middleware

The `interpolate` middleware is responsible for dynamic and one-time text interpolation from the state into the HTML view.

- name: interpolate
- middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- type: content middleware
- ignores: element nodes
- [docs](http://nx-framework.com/docs/middlewares/interpolate)

## Installation

`npm install @nx-js/interpolate-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const interpolate = require('@nx-js/interpolate-middleware')

component()
  .useOnContent(observe)
  .useOnContent(interpolate)
  .register('interpolate-comp')
```

```html
<interpolate-comp>
  <p>${name} is ${age | unit 'year'} old</p>
</interpolate-comp>
```
npm package: @nx-js/limiters
Description: Limiters for the NX compiler util.
Author: Miklos Bertalan
Latest version: 1.0.0

# Limiters

This repository contains a collection of rate limiters for the
[compiler utility](https://github.com/nx-js/compiler-util). It creates an registers the
following limiters.

- if: Has one parameter. If the parameter is falsy, the event handler won't be called.
- delay: Has a number parameter and delays the event handler by that many milliseconds. The delay is 200 milliseconds by default.
- debounce: Has a number parameter and causes the event handler to only execute, if the event doesn't happen for at least that many milliseconds. The parameter is 200 milliseconds by default.
- throttle: Has a number parameter and causes the event handler to execute only if it didn't execute in the last interval. The parameter is 200 - milliseconds by default.
- key: Only handles the event if it matches with one of the keys provided as arguments. If the event is not a keyboard event, this limiter has no effect. For the name of special keys see [this page](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).

You can learn more
about NX rate limiters [here](http://nx-framework/docs/middlewares/interpolate).
npm package: @nx-js/meta-middleware
Description: An NX middleware, responsible for handling metadata and analytics.
Author: Miklos Bertalan
Latest version: 1.0.1

# The meta middleware

The `meta` middleware is responsible for handling page metadata and analytics.

- name: meta
- direct middleware dependencies: none
- all middleware dependencies: none
- type: component middleware
- [docs](http://nx-framework.com/docs/middlewares/meta)

## Installation

`npm install @nx-js/meta-middleware`

## Usage

```js
const component = require('@nx-js/core')
const meta = require('@nx-js/meta-middleware')

component()
  .use(meta({
    title: 'Home page',
    description: 'The home page of my project, which is ...',
    author: 'Me',
    keywords: ['home', 'page'],
    robots: 'nofollow',
    analytics: '/home'
  }))
  .register('page-comp')
```

```html
<page-comp></page-comp>
```
npm package: @nx-js/observe-middleware
Description: An NX middleware, responsible for reactivity and observables.
Author: Miklos Bertalan
Latest version: 2.0.0

# The observe middleware

The `observe` middleware wraps the state in an observable and handles observability.

- name: observe
- middleware dependencies: none
- all middleware dependencies: none
- type: component or content middleware
- [docs](http://nx-framework.com/docs/middlewares/observe)

## Installation

`npm install @nx-js/observe-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')

component()
  .useOnContent(observe)
  .register('observing-comp')
```
npm package: @nx-js/params-middleware
Description: An NX middleware, responsible for query parameter routing.
Author: Miklos Bertalan
Latest version: 2.0.0

# The params middleware factory

The `params` middleware factory is responsible for automatically synchronizing state properties with query parameters.

- name: params
- direct middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware)
- type: component middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/params)

## Installation

`npm install @nx-js/params-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const params = require('@nx-js/params-middleware')

component()
  .use(observe)
  .use(params({
    paramName: {history: true, type: 'string'}
  }))
  .register('comp-name')
```
npm package: @nx-js/props-middleware
Description: An NX middleware, responsible for injecting properties into reusable components.
Author: Miklos Bertalan
Latest version: 1.0.0

# The props middleware

The `props` middleware is responsible for injecting static or dynamic properties into reusable components.

- name: props
- middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- type: component middleware
- [docs](http://nx-framework.com/docs/middlewares/props)

## Installation

`npm install @nx-js/props-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const props = require('@nx-js/props-middleware')

component()
  .use(observe)
  .use(attributes)
  .use(props('name', 'age', 'items'))
  .register('props-comp')
```

```html
<props-comp name="Bob" age="12" @items="myItems">Hello World!</props-comp>
```
npm package: @nx-js/ref-middleware
Description: An NX middleware, responsibe for handling internal references.
Author: Miklos Bertalan
Latest version: 2.0.0

# The ref middleware

The `ref` middleware is responsible for handling internal references.

- name: ref
- middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- type: component or content middleware
- ignores: text nodes
- [docs](http://nx-framework.com/docs/middlewares/route)

## Installation

`npm install @nx-js/ref-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const ref = require('@nx-js/ref-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .useOnContent(ref)
  .register('nav-comp')
```

```html
<nav-comp>
  <a iref="profile">Profile</a>
  <a iref="settings">Settings</a>
</nav-comp>
```
npm package: @nx-js/render-middleware
Description: An NX middleware, responsible for rendering and modularization.
Author: Miklos Bertalan
Latest version: 1.0.2

# The render middleware factory

The `render` middleware factory allows you to modularize your components into separate JavaScript, HTML and CSS files.

- name: render
- direct middleware dependencies: none
- all middleware dependencies: none
- type: component middleware
- [docs](http://nx-framework.com/docs/middlewares/render)

## Installation

`npm install @nx-js/render-middleware`

## Usage

```js
const component = require('@nx-js/core')
const params = require('@nx-js/render-middleware')

component()
  .use(render({
    template: require('./view.html'),
    style: require('./style.css')
  }))
  .register('comp-name')
```
npm package: @nx-js/route-middleware
Description: An NX middleware, responsible for path routing.
Author: Miklos Bertalan
Latest version: 2.0.0

# The route middleware

The `route` middleware is responsible for client-side routing.

- name: route
- direct middleware dependencies: none
- all middleware dependencies: none
- type: component middleware
- [docs](http://nx-framework.com/docs/middlewares/route)

## Installation

`npm install @nx-js/route-middleware`

## Usage

```js
const component = require('@nx-js/core')
const route = require('@nx-js/route-middleware')

component()
  .use(route)
  .register('router-comp')
```

```html
<router-comp>
  <div route="profile" default-route></div>
  <div route="settings"></div>
</router-comp>
```
npm package: @nx-js/router-util
Description: NX routing utilities.
Author: Miklos Bertalan
Latest version: 1.0.0

# The router util (WIP)

This library is part of the [NX framework](http://nx-framework.com).
It contains some routing related helper functions.

## Installation

```
$ npm install @nx-js/router-util
```

## Contributions

This library has the very specific purpose of supporting the
[NX framework](https://github.com/nx-js/framework).
Features should only be added, if they are used by the framework. Otherwise please fork.

Bug fixes, tests and doc updates are always welcome.

## Authors

  - [Miklos Bertalan](https://github.com/solkimicreb)

# License

  MIT
npm package: @nx-js/style-middleware
Description: An NX middleware, responsible for dynamic styling.
Author: Miklos Bertalan
Latest version: 1.0.0

# The style middleware

The `style` middleware is responsible for dynamic styling.

- name: style
- middleware dependencies: [attributes](https://github.com/nx-js/attributes-middleware)
- all middleware dependencies: [observe](https://github.com/nx-js/observe-middleware), [attributes](https://github.com/nx-js/attributes-middleware)
- processes: element nodes
- throws on: nothing
- use as: component or content middleware
- [docs](http://nx-framework/docs/middlewares/style)

## Installation

`npm install @nx-js/style-middleware`

## Usage

```js
const component = require('@nx-js/core')
const observe = require('@nx-js/observe-middleware')
const attributes = require('@nx-js/attributes-middleware')
const style = require('@nx-js/style-middleware')

component()
  .useOnContent(observe)
  .useOnContent(attributes)
  .useOnContent(style)
  .register('stylish-comp')
```

```html
<stylish-comp>
  <div @class="{big: true, outlined: shouldOutline}"></div>
</stylish-comp>
```
npm package: @nx-kz/go
Description: This is Nx plugin to use Go in a Nx workspace.
Author: kamikaze.zirou
Latest version: 0.0.6

# go

Nx plugin to use Go in a Nx workspace.

## Features

- Generation of go applications/modules
- Building, packaging, testing, etc your go projects
- Integration with Nx's dependency graph (through nx dep-graph or nx affected:dep-graph): this allows you to visualize the dependencies of any go projects inside your workspace, just like Nx natively does it for JS/TS-based projects!

## Getting started

First, make sure you have a Nx Workspace.

Next, install the go plugin:

```bash
## using npm
npm install -D @nx-kz/go
## Or using yarn
# yarn add -D @nx-kz/go
## Or using pnpm
# pnpm add -D @nx-kz/go
```

Generate a go project:

```bash
# generating application
nx g @nx-kz/go:app your-app-name
## Or generating library
# nx g @nx-kz/go:lib your-lib-name
```

## Usage

### Linting the go project

```bash
nx lint your-project-name
```

By default, lint the go-project using the `go vet` command.

### Testing the go project

```bash
nx test your-project-name
```

### Building the application

```bash
nx build your-app-name
```

By default, this command builds the application using the `go build` command, and stores the output in the dist/apps/your-app-name.


### Serving the application

```bash
nx serve your-app-name
```

Serves the application using the `go run` command.

### Using dependency graph

Setup with the following command:

```bash
nx g @nx-kz/go:setup
```

Then run the following command:

```bash
nx graph
```
npm package: @nx-libs/nx-aws-cache
Description: AWS S3 Cache plugin for Nx
Author: Matthew Revell
Latest version: 1.2.1

# nx-aws

nx-aws is a set of plugins for NRWL NX (a set of Extensible Dev Tools for Monorepos).

# @nx-aws-plugin/nx-aws-cache

A tool for using AWS S3 as a distributed computational cache for Nx.

## Setup

Install the package by running:

```bash
yarn add @nx-aws-plugin/nx-aws-cache
npm i @nx-aws-plugin/nx-aws-cache
```

Then run the init schematic by running:

```bash
yarn nx generate @nx-aws-plugin/nx-aws-cache:init
npm run nx generate @nx-aws-plugin/nx-aws-cache:init
```

This will make the necessary changes to nx.json in your workspace to use nx-aws-cache runner.

## AWS settings

There are two ways to set-up AWS options:

### Using nx.json

```json
{
  "tasksRunnerOptions": {
  "default": {
    "runner": "@nx-aws-plugin/nx-aws-cache",
    "options": {
      ...
      "awsRegion": "eu-central-1",
      "awsBucket": "bucket-name",
      "awsProfile": "profile-1",
      "awsEndpoint": "http://custom.de-eu.myhost.com",
    }
  }
}
```

### Using environment variables

```bash
NX_AWS_REGION=eu-central-1
NX_AWS_BUCKET=bucket-name
NX_AWS_PROFILE=profile-1
NX_AWS_ENDPOINT=[URL] # default s3.[region].amazonaws.com
```

> Environment variables can be set using `.env` file - check [dotenv documentation](https://www.npmjs.com/package/dotenv).

## Disabling S3 cache

Remote cache can be disabled in favor of local cache only using an environment variable

```bash
NX_AWS_DISABLE=true
```

## Authentication

### Default

AWS authentication can be set-up using default environment variables or using shared credentials, based on [AWS documentation](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html).

### SSO login

To authenticate with SSO via CLI run

`aws sso login`

AWS SDK v3 is used under the hood with a support for [SSO login](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html).

### Custom environment variables

Custom environment variables can be set for an alternate way of authentication

```bash
NX_AWS_ACCESS_KEY_ID=[secret]
NX_AWS_SECRET_ACCESS_KEY=[secret]
```

## Build

Run `yarn nx build nx-aws-cache` to build the plugin. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Running unit tests

Run `yarn nx test nx-aws-cache` to execute the unit tests via [Jest](https://jestjs.io).

Run `yarn nx affected:test` to execute the unit tests affected by a change.

## Running end-to-end tests

Run `yarn nx e2e nx-aws-cache` to execute the end-to-end tests via [Cypress](https://www.cypress.io).

Run `yarn nx affected:e2e` to execute the end-to-end tests affected by a change.

## Credits

This repository is based on a similar NX plugin using Azure Storage [@nx-azure/storage-cache](https://github.com/microsoft/nx-azure) which was inspired by Nx Cloud Plugin by [Nrwl](https://github.com/nrwl/nx).