open-index/open-npm huggingface dataset:
npm package: @robgietema/generator-nick
Description: Generator for Nick
Latest version: 0.0.21

# Yeoman Nick App Generator

@robgietema/generator-nick is a Yeoman generator that helps you to set up Nick via command line.

## Installation

First, install [Yeoman](http://yeoman.io) and @robgietema/generator-nick using [npm](https://www.npmjs.com/) (we assume you have pre-installed [node.js](https://nodejs.org/)).

```bash
npm install -g yo
npm install -g @robgietema/generator-nick
```

## Usage

### Creating a new Nick project using `npm init`

```bash
npm init yo @robgietema/nick
```

This is the shortcut for using `npm init` command. It uses Yeoman (`yo`) and `@robgietema/generator-nick` and execute them without having to be installed globally.

Answer the prompt questions to complete the generation process.

### Creating a new Nick project

```bash
yo @robgietema/nick
```

This will bootstrap a new Nick project inside the current folder.

### Start Nick with `pnpm start`

Start Nick with:

```bash
pnpm start
```

This runs the project in development mode.

Consult the Nick docs for further details:

https://nickcms.org

### Run unit tests with `pnpm test`

Runs all the tests.

### Update translations with `pnpm i18n`

Runs the test i18n runner which extracts all the translation strings and generates the needed files.
npm package: @robhan-cdk-lib/aws_aps
Description: AWS CDK Construct Library for Amazon Managed Service for Prometheus
Author: Robert Hanuschke
Latest version: 0.0.220

# @robhan-cdk-lib/aws_aps

AWS Cloud Development Kit (CDK) constructs for Amazon Managed Service for Prometheus.

In [aws-cdk-lib.aws_aps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_aps-readme.html), there currently only exist L1 constructs for Amazon Managed Service for Prometheus.

While helpful, they miss convenience like:

- advanced parameter checking (min/max number values, string lengths, array lengths...) before CloudFormation deployment
- proper parameter typing, e.g. enum values instead of strings
- simply referencing other constructs instead of e.g. ARN strings

Those features are implemented here.

The CDK maintainers explain that [publishing your own package](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md#publishing-your-own-package) is "by far the strongest signal you can give to the CDK team that a feature should be included within the core aws-cdk packages".

This project aims to develop aws_aps constructs to a maturity that can potentially be accepted to the CDK core.

It is not supported by AWS and is not endorsed by them. Please file issues in the [GitHub repository](https://github.com/robert-hanuschke/cdk-aws_aps/issues) if you find any.

## Example use

```typescript
import * as cdk from 'aws-cdk-lib';
import { Subnet } from 'aws-cdk-lib/aws-ec2';
import { Cluster } from 'aws-cdk-lib/aws-eks';
import { Construct } from 'constructs';
import { Workspace, RuleGroupsNamespace, Scraper } from '@robhan-cdk-lib/aws_aps';

export class AwsApsCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const workspace = new Workspace(this, 'MyWorkspace', {});
    new RuleGroupsNamespace(this, 'MyRuleGroupsNamespace', { workspace, data: '<myRulesFileData>', name: 'myRuleGroupsNamespace' });
    new Scraper(this, 'MyScraper', {
      destination: {
        ampConfiguration: {
          workspace,
        },
      },
      source: {
        eksConfiguration: {
          cluster: Cluster.fromClusterAttributes(this, 'MyCluster', {
            clusterName: 'clusterName',
          }),
          subnets: [
            Subnet.fromSubnetAttributes(this, 'MySubnet', {
              subnetId: 'subnetId',
            }),
          ],
        },
      },
      scrapeConfiguration: {
        configurationBlob: '<myScrapeConfiguration>',
      },
    });
  }
}
```

## License

MIT
npm package: @robhan-cdk-lib/aws_grafana
Description: AWS CDK Construct Library for Amazon Managed Grafana
Author: Robert Hanuschke
Latest version: 0.0.286

# @robhan-cdk-lib/aws_grafana

AWS Cloud Development Kit (CDK) constructs for Amazon Managed Grafana.

In [aws-cdk-lib.aws_grafana](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_grafana-readme.html), there currently only exist L1 constructs for Amazon Managed Grafana. 

While helpful, they miss convenience like:

- advanced parameter checking (min/max number values, string lengths, array lengths...) before CloudFormation deployment
- proper parameter typing, e.g. enum values instead of strings
- simply referencing other constructs instead of e.g. ARN strings

Those features are implemented here.

The CDK maintainers explain that [publishing your own package](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md#publishing-your-own-package) is "by far the strongest signal you can give to the CDK team that a feature should be included within the core aws-cdk packages".

This project aims to develop aws_grafana constructs to a maturity that can potentially be accepted to the CDK core.

It is not supported by AWS and is not endorsed by them. Please file issues in the [GitHub repository](https://github.com/robert-hanuschke/cdk-aws_grafana/issues) if you find any.

## Example use

```typescript
import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";
import {
  AccountAccessType,
  AuthenticationProviders,
  PermissionTypes,
  Workspace,
} from "@robhan-cdk-lib/aws_grafana";
import { Role, ServicePrincipal } from "aws-cdk-lib/aws-iam";

export class AwsGrafanaCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const grafanaRole = new Role(this, "GrafanaWorkspaceRole", {
      assumedBy: new ServicePrincipal("grafana.amazonaws.com"),
      description: "Role for Amazon Managed Grafana Workspace",
    });

    const workspace = new Workspace(this, "Workspace", {
      accountAccessType: AccountAccessType.CURRENT_ACCOUNT,
      authenticationProviders: [AuthenticationProviders.AWS_SSO],
      permissionType: PermissionTypes.SERVICE_MANAGED,
      role: grafanaRole,
    });
  }
}
```

## License

MIT
npm package: @robhan-cdk-lib/aws_mwaa
Description: AWS CDK Construct Library for Amazon Managed Workflows for Apache Airflow
Author: Robert Hanuschke
Latest version: 0.0.127

# @robhan-cdk-lib/aws_mwaa

AWS Cloud Development Kit (CDK) constructs for Amazon Managed Workflows for Apache Airflow (MWAA).

In [aws-cdk-lib.aws_mwaa](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_mwaa-readme.html), there currently only exist L1 constructs for Amazon Managed Workflows for Apache Airflow (MWAA).

While helpful, they miss convenience like:

- advanced parameter checking (min/max number values, string lengths, array lengths...) before CloudFormation deployment
- proper parameter typing, e.g. enum values instead of strings
- simply referencing other constructs instead of e.g. ARN strings

Those features are implemented here.

The CDK maintainers explain that [publishing your own package](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md#publishing-your-own-package) is "by far the strongest signal you can give to the CDK team that a feature should be included within the core aws-cdk packages".

This project aims to develop aws_mwaa constructs to a maturity that can potentially be accepted to the CDK core.

It is not supported by AWS and is not endorsed by them. Please file issues in the [GitHub repository](https://github.com/robert-hanuschke/cdk-aws_mwaa/issues) if you find any.

## Example use

```typescript
import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";
import {
  AirflowVersion,
  Environment,
  EnvironmentClass,
} from "@robhan-cdk-lib/aws_mwaa";

export class AwsMwaaCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const environment = new Environment(this, "Environment", {
      airflowConfigurationOptions: {
        key: "value",
      },
      name: "myEnvironment",
      airflowVersion: AirflowVersion.V3_0_6,
      environmentClass: EnvironmentClass.MW1_MEDIUM,
      minWebservers: 2,
      maxWebservers: 4,
      minWorkers: 2,
      maxWorkers: 4,
    });
  }
}
```

## License

MIT
npm package: @robhan-cdk-lib/utils
Description: Utility functions for robhan-cdk-lib projects.
Author: Robert Hanuschke
Latest version: 0.0.222

# @robhan-cdk-lib/utils

Utility functions for robhan-cdk-lib projects.

## Functionalities

### Validation

Defines commonly used functions for validating user provided attribute values.

Example:

```typescript
import { validateArrayLength } from '@robhan-cdk-lib/utils';

const tags = ['typescript', 'validation'];

const errors = validateArrayLength({
  value: tags,
  min: 3,
  max: 5,
  messagePrefix: 'Tags: ',
});

if (errors.length > 0) {
  console.error('Validation failed:', errors);
} else {
  console.log('Array length is valid.');
}

```

Expected output:

```
Validation failed: [ 'Tags: must have at least 3 elements' ]
```

## License

MIT
npm package: @robhemstede/libsync
Description: Sync library binaries that should not be in the SCM tool
Author: Rob Hemstede
Latest version: 1.0.9

# LibSync
 
A tool to sync and share software dependencies and binary files that you don't want to add to the SCM tool (git).
 
The tool looks for a file named 'libsync.json'. Your project tree can contain one or more then one of these json files. From this file it will read the local path en remote path that it needs to synchronize.
 
as an example :  libsync.json
 
``` javascript
[{
    "name": "googletest", 
    "storepath": "\\\\10.0.0.2\\Software\\lib", 
    "localpath": "../gtest/googletest",
    "down": false,
    "force": false
}]
``` 

The store path can be platform depeneded. In that case you 
can add path for each platform.  

``` javascript
[{
    "name": "googletest", 
    "storepath": {
        "win32": "\\\\10.0.0.2\\Software\\lib", 
        "linux": "~/mnt/Software/lib" 
    },
    "localpath": "../gtest/googletest",
    "down": true,
    "force": false
}]
``` 


 
When storing the **name** is added the the storage path. It will also add an additional sub directory for the platform name.  
 
For instance when running the above on a windows client. The storage path will be.
 
_\\\\10.0.0.2\\Software\\lib\\googletest\\win32-x64\\_
 
When _down_ is true then nothing will be uploaded to your storage path. Files will only be moved from server to client.  
 
When _force_ is set to true files will be downloaded when there are local changes. even if the local changes are newer as the version on the server
npm package: @robherley/actions-log-parser
Description: GitHub Actions log parser
Author: Robert Herley
Latest version: 1.0.0

# @robherley/actions-log-parser

A TypeScript library for parsing GitHub Actions log streams with ANSI color support, collapsible groups, and text formatting.

## Installation

```bash
npm install @robherley/actions-log-parser
```

## Usage

### Basic Log Parsing

```typescript
import { LogParser } from '@robherley/actions-log-parser';

const parser = new LogParser();

// Add log lines (typically from GitHub Actions log stream)
parser.add('##[group]Building project');
parser.add('npm install');
parser.add('npm run build');
parser.add('##[endgroup]');

// Get parsed lines
const lines = parser.lines;
console.log(lines);
```

### Handling Groups and Commands

```typescript
import { LogParser, Command } from '@robherley/actions-log-parser';

const parser = new LogParser();

// Groups are automatically detected and parsed
parser.add('##[group]Setup Phase');
parser.add('Setting up environment...');
parser.add('##[endgroup]');

// Commands like warnings and errors are parsed
parser.add('##[warning]This is a warning message');
parser.add('##[error]This is an error message');

// Access parsed content
console.log(parser.getVisibleLines()) // [ 0, 1, 2 ]
parser.lines[0].group.open = true
console.log(parser.getVisibleLines()) // [ 0, [ 0, 0 ], 1, 2 ]
```

### Working with ANSI Colors

```typescript
import { LogParser, Styles } from '@robherley/actions-log-parser';

const parser = new LogParser();
const styles = new Styles();

// Parse a line with ANSI escape codes
parser.add('\x1b[32mSuccess!\x1b[0m Build completed');

const line = parser.lines[0];
console.log(line.ansis) // Map(2) { 0 => [ { code: 7, args: [Array] } ], 8 => [ { code: 0 } ] }
```

### Search

```typescript
const parser = new LogParser();

// Add some log content
parser.add('Building application...');
parser.add('Running tests...');
parser.add('Build complete!');

// Set search term
const matches = parser.setSearch('build');
console.log(matches) // 2
```

## Demo

See [https://logs.reb.gg](https://logs.reb.gg) for an interactive demo.

## License

MIT
npm package: @robhicks/svelte-adapter-gun
Latest version: 0.0.3

# @sveltejs/adapter-node

[Adapter](https://kit.svelte.dev/docs#adapters) for SvelteKit apps that generates a standalone Node server.

## Usage

Install with `npm i -D @sveltejs/adapter-node@next`, then add the adapter to your `svelte.config.js`:

```js
// svelte.config.js
import adapter from '@sveltejs/adapter-node';

export default {
	kit: {
		adapter: adapter({
			// default options are shown
			out: 'build',
			precompress: false,
			env: {
				host: 'HOST',
				port: 'PORT'
			}
		})
	}
};
```

## Options

### out

The directory to build the server to. It defaults to `build` — i.e. `node build` would start the server locally after it has been created.

### precompress

Enables precompressing using gzip and brotli for assets and prerendered pages. It defaults to `false`.

### env

By default, the server will accept connections on `0.0.0.0` using port 3000. These can be customised with the `PORT` and `HOST` environment variables:

```
HOST=127.0.0.1 PORT=4000 node build
```

You can specify different environment variables if necessary using the `env` option:

```js
env: {
	host: 'MY_HOST_VARIABLE',
	port: 'MY_PORT_VARIABLE'
}
```

```
MY_HOST_VARIABLE=127.0.0.1 MY_PORT_VARIABLE=4000 node build
```

## Custom server

The adapter creates two files in your build directory — `index.js` and `handler.js`. Running `index.js` — e.g. `node build`, if you use the default build directory — will start a server on the configured port.

Alternatively, you can import the `handler.js` file, which exports a handler suitable for use with [Express](https://github.com/expressjs/expressjs.com), [Connect](https://github.com/senchalabs/connect) or [Polka](https://github.com/lukeed/polka) (or even just the built-in [`http.createServer`](https://nodejs.org/dist/latest/docs/api/http.html#httpcreateserveroptions-requestlistener)) and set up your own server:

```js
// my-server.js
import { handler } from './build/handler.js';
import express from 'express';

const app = express();

// add a route that lives separately from the SvelteKit app
app.get('/healthcheck', (req, res) => {
	res.end('ok');
});

// let SvelteKit handle everything else, including serving prerendered pages and static assets
app.use(handler);

app.listen(3000, () => {
	console.log('listening on port 3000');
});
```

## Deploying

You will need the output directory (`build` by default), the project's `package.json`, and the production dependencies in `node_modules` to run the application. Production dependencies can be generated with `npm ci --prod`, you can also skip this step if your app doesn't have any dependencies. You can then start your app with

```bash
node build
```

## Changelog

[The Changelog for this package is available on GitHub](https://github.com/sveltejs/kit/blob/master/packages/adapter-node/CHANGELOG.md).

## License

[MIT](LICENSE)
npm package: @robilars/babel-plugin-styled-components
Description: Improve the debugging experience and add server-side rendering support to styled-components
Latest version: 1.10.9

This is a fork of [styled-components/babel-plugin-styled-components](https://github.com/styled-components/babel-plugin-styled-components) with the addion of a bug pach that insuare that all styled-components IDs are prefixed with `sc-`

# `babel-plugin-styled-components`

This plugin is a highly recommended supplement to the base styled-components library, offering some useful features:

- consistently hashed component classNames between environments (a must for server-side rendering)
- better debugging through automatic annotation of your styled components based on their context in the file system, etc.
- various types of minification for styles and the tagged template literals styled-components uses

## Quick start

Install the plugin first:

```
npm install --save-dev babel-plugin-styled-components
```

Then add it to your babel configuration:

```JSON
{
  "plugins": ["babel-plugin-styled-components"]
}
```

## Documentation

**The documentation for this plugin lives on [the styled-components website](https://www.styled-components.com/docs/tooling#babel-plugin)!**

- [Usage](https://www.styled-components.com/docs/tooling#usage)
- [Better debugging](https://www.styled-components.com/docs/tooling#better-debugging)
- [Minification](https://www.styled-components.com/docs/tooling#minification)

## License

Licensed under the MIT License, Copyright © 2016-present Vladimir Danchenkov and Maximilian Stoiber.

See [LICENSE.md](./LICENSE.md) for more information.
npm package: @robin-drexler/react-if
Description: React component to declaratively render react elements conditionally.
Latest version: 1.0.1

# @robin-drexler/react-if

React component to declaratively render react elements conditionally.

## Installation

### yarn

```
yarn add @robin-drexler/react-if
```

### npm

```
npm install @robin-drexler/react-if
```

## Usage

### Simple usage without else

If you do not have an else case, you can omit the `Then` component.

```js
import { If } from "@robin-drexler/react-if";

const App = () => (
  <div>
    <If condition={true}>
      <div>I am rendered :)</div>
    </If>
  </div>
);
```

### Usage with else

When there is an else case, you need to nest `Then` and `Else` inside the `If`

```js
import { If, Then, Else } from "@robin-drexler/react-if";

const App = () => (
  <div>
    <If condition={false}>
      <Then>
        <div>Then is rendered :)</div>
      </Then>
      <Else>
        <div>Else is rendered :)</div>
      </Else>
    </If>
  </div>
);
```