open-index/open-npm huggingface dataset:
npm package: @rogersau123/nsw-ds-react
Description: Reusable React Components from the NSW Design System. Forked from 
Author: James Rogers
Latest version: 1.0.3

# NSW Design System React Library

## Changes
- Bumped dependancies
- Added support for TextArea in Form.

[![npm version](https://badge.fury.io/js/nsw-ds-react.svg)](https://badge.fury.io/js/nsw-ds-react)

![alt text](https://www.digital.nsw.gov.au/sites/default/files/2021-04/nsw-ds-react_0.jpg "NSW DS + React Logo")

## Install

```bash
npm install @rogersau123/nsw-ds-react nsw-design-system
```


Add the styles separately in your main `App.js` file

```js
import 'nsw-design-system/dist/css/main.css'
```


In your `index.html` document add this line of code inside the `<head>` tag. Or install [icon](https://www.npmjs.com/package/material-icons) and [font](https://www.npmjs.com/package/@fontsource/public-sans) from npm
```
<link href="https://fonts.googleapis.com/css2?family=Public+Sans:ital,wght@0,400;0,700;1,400&display=swap" rel="stylesheet">
<link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
```

## Usage

Refer to individual components' usage in [Storybook](https://digitalnsw.github.io/nsw-design-system-react)

Here's how you import the component:
```jsx
import React, { Component } from 'react'

import { Callout } from 'nsw-ds-react'

class Example extends Component {
  render() {
    return (
     <Callout title="Title of callout">
       <p>Description of callout</p>
     </Callout>
    )
  }
}
```
## Attribution
The components library is adapted from:

https://github.com/govau/design-system-components/

## License

MIT © [digitalnsw](https://github.com/digitalnsw)
npm package: @rogervee/discord-speech-recognition
Description: Extension for making discord speech recognition bots.
Author: Rei-x
Latest version: 3.4.1

# Discord Speech Recognition Extension

This is an extension for [discord.js](https://discord.js.org) library that makes creating discord speech recognition bots as easy as common text bots.

## Installation

**Discord.js v14**:

```
npm i discord-speech-recognition
```

Checkout simpleBot example in examples directory for ready-to-use bot.

**Discord.js v13**:

```
npm i discord-speech-recognition@2
```

**Discord.js v12**:

```
npm i discord-speech-recognition@1
```


## Docs

<https://discordsr.netlify.app/>

## Example usage for discord.js v14

```javascript
const { Client, GatewayIntentBits } = require("discord.js");
const { joinVoiceChannel } = require("@discordjs/voice");
const { addSpeechEvent } = require("discord-speech-recognition");

const client = new Client({
  intents: [
        GatewayIntentBits.GuildVoiceStates,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.Guilds,
        GatewayIntentBits.MessageContent,
      ],
});
addSpeechEvent(client);

client.on("messageCreate", (msg) => {
  const voiceChannel = msg.member?.voice.channel;
  if (voiceChannel) {
    joinVoiceChannel({
      channelId: voiceChannel.id,
      guildId: voiceChannel.guild.id,
      adapterCreator: voiceChannel.guild.voiceAdapterCreator,
      selfDeaf: false,
    });
  }
});

client.on("speech", (msg) => {
  // If bot didn't recognize speech, content will be empty
  if (!msg.content) return;

  msg.author.send(msg.content);
});

client.on("ready", () => {
  console.log("Ready!");
});

client.login("token");
```

You need to enable message content for this example, so it can react to messages in chat.

![](https://i.imgur.com/06doHXE.png)
npm package: @roggc/react-server-dom-esm
Description: React Server Components bindings for DOM using ESM. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.
Latest version: 0.0.0-b061b597-20251212

# react-server-dom-esm

Experimental React Flight bindings for DOM using ESM.

**Use it at your own risk.**
npm package: @rogin/config
Description: To install dependencies:
Latest version: 0.0.13

# @rogin/web-config

To install dependencies:

```bash
bun install
```

To run:

```bash
bun run index.ts
```

This project was created using `bun init` in bun v1.1.8. [Bun](https://bun.sh)
is a fast all-in-one JavaScript runtime.
npm package: @rogin/web-config
Description: To install dependencies:
Latest version: 0.0.12

# @rogin/web-config

To install dependencies:

```bash
bun install
```

To run:

```bash
bun run index.ts
```

This project was created using `bun init` in bun v1.1.8. [Bun](https://bun.sh)
is a fast all-in-one JavaScript runtime.
npm package: @rognstadragnar/deep-enough-equals
Description: Check if to things are equal-ish
Author: Ragnar Rognstad
Latest version: 0.2.1

<p align="center"><strong>deep-enough-equals</strong></p>
<p align="center"><i>When shallow is too shallow and deep is too deep</i></p>

## Installation

```
npm i @rognstadragnar/deep-enough-equals
```

## Usage

```javascript
import { deepEnoughEquals } from '@rognstadragnar/deep-enough-equals'

const thingA = { some: ['thing'] }
const thingB = { some: ['thing'] }
const thingC = { some: ['other', 'thing'] }

deepEnoughEquals(thingA, thingB)
// > true

deepEnoughEquals(thingA, thingC)
// > false
```

## License

[MIT](LICENSE).
npm package: @rogntudju/checker
Description: A specialized HOC that detects useless re-renders in dev mode.
Latest version: 0.0.11

# `@rogntudju/checker`

A specialized HOC that detects useless re-renders in dev mode.

## Usage

```javascript
import { checker } from "@rogntudju/checker";
import { Component } from "yourComponent.jsx";

// Builds your specialized component that checks for useless re-renders
const Wrapper = checker(connect);
```

## Enabling or disabling checks

By default, checks are enabled only in dev mode (`process.env.NODE_ENV !== "production"`).

If you wish to override this, there an optional parameter to the `checker()` function.

```typescript
const checkEnabled: boolean = isUselessRenderingCheckEnabled();
const Wrapper = checker(connect, checkEnabled);
```
npm package: @rogntudju/connect
Description: A specialized redux connect() implementation that detects useless re-renders in dev mode.
Latest version: 0.0.11

# `@rogntudju/connect`

A specialized redux connect() implementation that detects useless re-renders in dev mode.

## Usage

```javascript
import { connect } from "react-redux";
import { buildConnect } from "@rogntudju/connect";
import { Component } from "yourComponent.jsx";

// Builds your specialized redux connect that checks for useless re-renders
const rconnect = buildConnect(connect);

// Wraps your component as usual
const ComponentWrapped = rconnect(mapsStateToProps)(Component);
```

## Enabling or disabling checks

By default, checks are enabled only in dev mode (`process.env.NODE_ENV !== "production"`).

If you wish to override this, there an optional parameter to the `buildConnect()` function.

```typescript
const checkEnabled: boolean = isUselessRenderingCheckEnabled();
const rconnect = buildConnect(connect, checkEnabled);
```

## Typescript

Intentionally this doesn't use the redux type definitions, as this would make the library tied to your exact redux version.

However, since this library makes a no real use of redux, as it forwards parameters to redux, just replaces the component to be wrapped), I've chosen not to use the redux type definitions.

Therefore buildConnect is defined as `buildConnect<C>`where C is redux's connect().
npm package: @rogolev/value
Description: Библиотека, переосмысливающая типы данных и работу с ними.
Author: Дмитрий Роголев
Latest version: 0.0.5

# value.js

**value.js** &mdash; Библиотека для **JavaScript**, переосмысливающая типы данных и работу с ними.

## Документация

[Типы данных в value.js](./docs/types.md).

[Классы](./docs/classes.md)

[Помощники для работы с типами данных value.js](./docs/helpers.md)

## Установка

```sh
npm install @rogolev/value
```

## Примеры использования

```js
import {
    array,
    is_array,
    is_object,
    is_class,
    is_function,
    is_int,
    is_float,
    gettype,
    value,
} from '@rogolev/value.js';

// Создаем ассоциативный массив - контейнер пар ключ-значение
const assoc = array({ key1: 'value1', key2: 'value2', key3: 'value3' });

console.log(assoc); // {key1: 'value1', key2: 'value2', key3: 'value3'}

// Ассоциативные массивы создаются с помощью конструкции Object.create(null)
console.log(Object.getPrototypeOf(assoc)); // null

// Функция array добавляет итератор Symbol.iterator к ассоциативным массивам
for (const [key, value] of assoc) {
    console.log(key, value);
}

// Ассоциативные массивы являются массивами
console.log(is_array(assoc)); // true

// Списки являются массивами
console.log(is_array([1, 2, 3])); // true

class stdClass {}
function MyFunction() {}

const object = new stdClass();
const objFunc = new MyFunction();

// Экземпляры классов не являются массивами
console.log(is_array(object)); // false

// Экземпляр класса является объектом
console.log(is_object(object)); // true

// Экземпляр функции не является объектом
console.log(is_object(objFunc)); // false

// Класс является классом
console.log(is_class(stdClass)); // true

// Функция не является классом
console.log(is_class(MyFunction)); // false

// Функция является функцией
console.log(is_function(MyFunction)); // true

// Класс не является функцией
console.log(is_function(stdClass)); // false

// Целое число
console.log(is_int(3)); // true

// Число с плавающей точкой
console.log(is_float(3.14)); // true

// Получение типа
console.log(gettype(stdClass)); // "class"

// Использование функции value для создания экземпляра класса Value
const valInstance = value(123);
console.log(valInstance.get()); // 123
console.log(valInstance.getType()); // 'integer'
console.log(valInstance.isNumber()); // true

// Преобразование значения в строку и вывод на консоль
valInstance.print(); // 123

// Преобразование значения в массив
const arrayInstance = valInstance.toArray();
console.log(arrayInstance.get()); // [123]

// Преобразование значения в объект
const objectInstance = valInstance.toObject();
console.log(objectInstance.get()); // { value: 123 }
```

## Автор

Роголев Дмитрий Александрович

<drogolev@internet.ru>

<https://github.com/dmitry-rogolev>

## Лицензия

Этот проект лицензируется на условиях лицензии MIT. Подробности см. в файле [LICENSE](./LICENSE).
npm package: @rogonion/js-metadatamodel
Description: A library designed to manipulate, transform, and query complex data structures using a declarative Metadata Model. It provides tools for flattening/unflattening nested data, filtering, extracting column definitions, and handling database-like operations o
Author: Declan Joseph
Latest version: 1.0.1

https://github.com/rogonion/js-metadatamodel#README.md
npm package: @rogovdm/gatsby-source-mailchimp
Description: It's a plugin a wrote for my single usecase:
Author: RG
Latest version: 1.0.16

### Intro

It's a plugin a wrote for my single usecase:

> Display number of my newsletter subscribers in my gatsby blog

### Installation

```
yarn add @rogovdm/gatsby-source-mailchimp
```

### Usage

`gatsby-config.js`

```javascript
[
  {
    resolve: `@rogovdm/gatsby-source-mailchimp`,
    options: {
      id: '<id-of-your-list>',
      key: '<MAILCHIMP-API-KEY>'
    }
  }
];
```

`index.js`

```javascript
export const pageQuery = graphql`
  query {
    allMailchimpList {
      edges {
        node {
          id
          stats {
            member_count
          }
        }
      }
    }
  }
`;
```

- You can get `id` in settings of your list.
- You can can your API key in account setting of your mailchimp account.
npm package: @rogozhin/cast-with-schema
Description: Casting JS objects to correct types using JSON schemas
Author: Alexander Zinchuk
Latest version: 1.4.0

# cast-with-schema
[![NPM version](https://img.shields.io/npm/v/cast-with-schema.svg)](https://npmjs.com/package/cast-with-schema)

The way to cast data to types specified with [JSON schema](http://json-schema.org/).


### Arguments
- `source (object)` - Source object to be casted.
- `schema (object)` - JSON schema containing types definitions.
- `options (object)`
    - `allowNaN` — Whether or not to return `NaN` for non-parseable numbers. The default is `false` which will cast `NaN` to `0`.

### Example

May be used for query params casting:

```js
const qs = require('qs');
const castWithSchema = require('cast-with-schema');

const schema = {
  type: "object",
  properties: {
    param1: {
      type: 'string',
    },
    param2: {
      type: 'integer',
    },
    param3: {
      type: 'number',
    },
    param4: {
      type: 'boolean',
    },
  }
};

const query = 'param1=value&param2=777&param3=7.77&param4=false';
const parsed = qs.parse(query);
const casted = castWithSchema(query, schema);

/*
  `casted` is now:
  {
    param1: 'value',
    param2: 777,
    param3: 7.77,
    param4: false,
  }
*/

```

Supports `null` if schema is either:
```
type: ['..', 'null']
```
or
```
anyOf: [
  { type: '..' },
  { type: 'null' }
]
```

### See also

Check out [tinsypec](https://github.com/Ajaxy/tinyspec) for more smart JSON schema use cases.
npm package: @rogozhin/eslint-backend
Description: ## Install
Author: Lev Rogozhin
Latest version: 1.0.1

# eslint-backend

## Install

```bash
npm i -D @rogozhin/eslint-backend
```

## Usage

`.eslintrc.js`:

```javascript
{
  extends: [
    '@rogozhin/eslint-backend',
  ]
}
```
npm package: @rogozhin/eslint-config-backend
Description: ## Install
Author: Lev Rogozhin
Latest version: 1.0.4

# eslint-config-backend

## Install

```bash
npm i -D @rogozhin/eslint-config-backend
```

## Usage

`.eslintrc.js`:

```javascript
{
  extends: [
    '@rogozhin/eslint-config-backend',
  ]
}
```
npm package: @rogozhin/sequelize-serialize
Description: Automatic JSON serialization of Sequelize models and collections based on JSON Schema
Author: Alexander Zinchuk
Latest version: 1.0.5

# sequelize-serialize
[![NPM version](https://img.shields.io/npm/v/sequelize-serialize.svg)](https://npmjs.com/package/sequelize-serialize)

The way to serialize [Sequelize](sequelizejs.com) models using [JSON Schema](http://json-schema.org/).
Supports complex resources and associated models.

### Example

Let’s say we need to return all users with posts in the blog, including the comments to these posts:

```js
router.get('/blog/users', async (ctx) => {
  const users = await User.findAll({
    include: [{
      model: Post,
      required: true,
      include: [Comment]
    }]
  });

  ctx.body = serialize(users, schemas.UserWithPosts);
});
```

We can describe JSON fields for that with following schemas:
<details>
    <summary>Expand to check them here</summary>

```js
{
  "UserWithPosts": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string"
      },
      "isAdmin": {
        "type": "boolean"
      },
      "age": {
        "type": "integer"
      },
      "posts": {
        "type": "array",
        "items": {
          "$ref": "#/definitions/Post"
        }
      }
    },
    "required": [
      "name",
      "isAdmin",
      "posts"
    ]
  },

  "User": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string"
      },
      "isAdmin": {
        "type": "boolean"
      },
      "age": {
        "type": "integer"
      }
    },
    "required": [
      "name",
      "isAdmin"
    ]
  },

  "Post": {
    "type": "object",
    "properties": {
      "topic": {
        "type": "string"
      },
      "message": {
        "type": "string"
      },
      "comments": {
        "type": "array",
        "items": {
          "$ref": "#/definitions/Comment"
        }
      }
    },
    "required": [
      "topic",
      "message"
    ]
  },

  "Comment": {
    "type": "object",
    "properties": {
      "authorId": {
        "type": "integer"
      },
      "message": {
        "type": "string"
      }
    },
    "required": [
      "authorId",
      "message"
    ]
  },
```
</details>

### Nulls

Supports `null` if schema is either:
```
type: ['..', 'null']
```
or
```
anyOf: [
  { type: '..' },
  { type: 'null' }
]
```

### See also

Check out [tinsypec](https://github.com/Ajaxy/tinyspec) for more smart JSON schema use cases.
npm package: @rogu/tracker-runtime
Description: This is a runtime library for [@rogu/tracker-codegen](). However, you still need to setup the provider manually to make it works.
Author: broerjuang
Latest version: 0.2.0

# @rogu/tracker-runtime

This is a runtime library for [@rogu/tracker-codegen](). However, you still need to setup the provider manually to make it works.

## Overview

![tracker](./img/ss.png)

## Tracker Provider

Tracker Provider is a collection of modules that act as a container for your tracking service.

```ocaml
module __Your_Tracking_Service__ = {
  type t;
  let handler: t => unit
}
```

### Full Example

```ocaml
module Firebase = {
  type t = [ | `firebase];
  let handler = properties => {
    fun
    | `firebase => {
        Firebase.Analytics.make().logEvent(.
          properties##eventType,
          properties##context,
        );
      };
  };
};

module Internal = {
  type t = [ | `internal];

  let transform = properties =>
    Js.Json.[
      ("clientTimestamp", string @@ Js.Date.toString @@ Js.Date.make()),
      ("appVersion", string("0.0")),
      ("clientDevice", string("WEB")),
      ("clientOS", string("")),
      ("clientOSVersion", string("")),
      ("context", properties##context),
      ("deviceId", string("")),
      ("eventType", string @@  properties##eventType),
      ("eventVersion", number(0.0)),
      ("cookiesId", string @@ Session.make()),
      ("isLogged", boolean @@ false),
      ("memberId", string @@ UOC.get()),
      ("sessionId", string @@ Session.make()),
    ]
    |> Js.Dict.fromList
    |> Js.Json.object_
    |> Js.Json.stringify;

  let handler = properties =>
    fun
    | `internal => {
        Bs_fetch.(
          fetchWithInit(
            Config.config.apiEndpoint ++ "/event/tracker",
            RequestInit.make(
              ~method_=Post,
              ~body=BodyInit.make @@ transform(properties),
              (),
            ),
          )
        )
        |> ignore;
      };
};
```

## Tracker Module

This is the main module where you need to compose between the code from code generator and your own provider implementation.

```ocaml
module Make = RgTracker.Runtime.Make(LMS__Tracker);

include Make({

  type t = [ TrackerProvider.Internal.t | TrackerProvider.Firebase.t];

  let required = [|`internal|];

  let handler = properties =>
    fun
    | `internal as provider => TrackerProvider.Internal.handler(properties, provider)
    | `firebase as provider => TrackerProvider.Firebase.handler(properties, provider);
});

```

After you setup those two modules. You can use tracker as followings:

```ocaml

[@react.component]
let make = () => {
  <Button onPress={_ => Tracker.make(`generatedEvent(some_payload))}>
  </Button>
}
```

That code will only fire `internal` since it's the only required tracker to track.

However, if you want to track internal and firebase. You can do followings:

```ocaml
[@react.component]
let make = () => {
  <Button onPress={_ => Tracker.make(~providers=[|`firebase|],`generatedEvent(some_payload))}>
  </Button>
}
```
npm package: @rogue-zero/warify
Description: Create war for single page applications for Java EE 6 compliant servers.
Latest version: 0.1.14

# warify

Create war for single page applications for Java EE 6 compliant servers.

## Installation


### yarn

```
yarn add warify --dev
```

### npm

```
npm install warify --save-dev
```

## Usage

### JavaScript

```javascript
const warify = require("warify");
warify(inputPath, outputPath, (size) => {
    const warPath = path;
});
// example: const warPath = warify("./", "./my-war.war, (size) => {
//    console.log(size + " bytes file");
// });

console.log(warPath);
```

### CLI

```shell
warify <inputPath> <generated-war-name>
# outputs: war path
```

## Building

### Requirements

* Node.js
* Java
* Maven

### Build

```
yarn
yarn build
```
npm package: @rogueg/zen
Description: Karma replacement that runs your tests in seconds
Latest version: 0.4.0

Zen is an absurdly fast test runner. How fast? At Superhuman, running all 2.8k tests locally took about 30 minutes. With Zen, it takes 10 seconds. There are 3 main parts:

**Lambda workers** - when running all tests, Zen uploads your code to an S3 bucket and then spins up 600 Chrome instances in AWS Lambda to run all your tests. 

**Headless workers** - when you're running fewer tests (say, just one describe block) Zen will run your tests on a pool of local headless Chrome instances.

**Zen UI** - Let's you see which tests failed, and run them in the current tab to debug. When running in a tab, Zen shows you all the rendered DOM, making it a decent replacement for Storybook.

## Setup
This is a bit rough. Sorry! Hopefully soon I'll automate all this 😀

#### Deploy S3 bucket
We're going to put some build artifacts in this bucket before deploying the full stack.
```
aws cloudformation deploy --stack-name zen --template-file node_modules/@rogueg/zen/lib/aws-bucket-only.template --capabilities CAPABILITY_NAMED_IAM
```

#### Making Chrome Layer
You need a Lambda Layer that has a chromium binary. I've been using the excellent https://github.com/alixaxel/chrome-aws-lambda, but it requires a bit of work.

1. Download release for the version of Chrome you'd like
1. Use brotli to decompress bin/chromium.br
1. Create a zip file with just the decompressed chromium
1. Upload to the bucket
1. Use AWS's Lambda UI to create a layer from that zip
1. Get the ARN for the layer, and put it in `node_modules/@rogueg/zen/lib/aws.template` (I told you this was rough)

#### Make lambda code
You'll also need a zip of `lib/chrome.js`, `lib/lambda.js`, and `chrome-remote-interface`. Upload it to the bucket as `lambda-code.zip`

#### Deploy stack
This will deploy all the rest of the formation.
```
aws cloudformation deploy --stack-name zen --template-file node_modules/@rogueg/zen/lib/aws.template --capabilities CAPABILITY_NAMED_IAM
```

#### Config
Finally, create test/zen.config.js. Mine usually looks like this:
```
const webpackConfig = require('../webpack.config.js')

process.env.NODE_ENV = 'test'
webpackConfig.mode = 'development'
webpackConfig.entry = {bundle: ['./test/setup.tsx']}
webpackConfig.output.publicPath = 'webpack/'
webpackConfig.devtool = 'eval'

module.exports = {
  aws: {
    region: 'us-west-2',
    accessKeyId: 'XXX',
    secretAccessKey: 'XXX',
    assetBucket: 'XXX',
  },
  webpack: webpackConfig,
}
```
npm package: @roguejs/hocs
Description: Below are optional app customizations that we have SSR support for.
Author: Alid Castano
Latest version: 0.9.7

# @roguejs/hocs

Below are optional app customizations that we have SSR support for.

All you have to do is import and initialize the desired hoc in your `App.js` file.

*Note: Make sure to read the respective packages documentation for usage information.*

**Table of Contents**
- [State Management](#state-management)
- [Apollo Graphql](#apollo-graphql)

## State management

Rogue has optional support for [redux](https://github.com/reduxjs/redux).

First install it: 

```bash
npm install --save redux react-redux
```

Then, you must write a function for creating your store. You will pass this function to the redux hoc that we provide for you and we will call it with the `initialState` from SRR. Here's an example:

```js
import { createStore as createReduxStore, applyMiddleware } from 'redux'
import { composeWithDevTools } from 'redux-devtools-extension'
import thunkMiddleware from 'redux-thunk'
import { combineReducers } from 'redux'

export default function createStore (initialState) {
  const reducers = combineReducers({ ... add your reducers here ... })
  const enhancers = composeWithDevTools(applyMiddleware(thunkMiddleware))
  return createReduxStore(
    reducers, 
    initialState, 
    enhancers
  )
}
```

Lastly, import and initialize our Redux hoc in your `App.js` file:

```js
import withStore from 'rogue/hocs/redux'
import createStore from './store'

const App = () => (...)

export default withStore(createStore)(App)
```

## Apollo Graphql

Rogue has optional support for [react-apollo](https://github.com/apollographql/react-apollo).

First install it: 

```bash
npm install --save apollo react-apollo
```

Then, you must write a function for creating your apollo client. You will pass this function to the apollo hoc that we provide for you and we will call it with the `initialState` from SRR and a `ctx` object if called from the server. Here's an example:


```js
import ApolloClient, { InMemoryCache } from 'apollo-boost'
import { isServer } from 'rogue'

export default function createClient(initialState, ctx) {
  return new ApolloClient({
    uri: 'http://localhost:4000/graphql',
    connectToDevTools: !isServer,
    ssrMode: isServer, // Disables forceFetch on the server (so queries are only run once)
    cache: new InMemoryCache().restore(initialState || {})
  })
}
```

Lastly, import and initialize our Apollo hoc in your `App.js` file:

```js
import withApollo from 'rogue/hocs/apollo'
import createClient from './apollo'

const App = () => (...)

export default withApollo(createClient)(App)
```

Important: If you're using other hocs in your `App.js`, make sure that Apollo is the top most one that you include. 

For example: 

```js
import { compose } from 'recompose'

const App = () => (...)

export default compose(
  withApollo(createClient),
  withStore(createStore)
)(App)
```
npm package: @roguib/ng-vs-snippets
Description: Automatic VS Code snippet file generation for Angular codebases
Author: roguib
Latest version: 0.3.0

# ng-vs-snippets

![ts](https://badgen.net/badge/Built%20With/TypeScript/blue) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![made-for-VSCode](https://img.shields.io/badge/Made%20for-VSCode-1f425f.svg)](https://code.visualstudio.com/) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)

Automatic VS Code snippet file generation for Angular codebases. Seamlessly maintain up-to-date VS Code snippets of all of your code.

Currently, we support snippet generation from the following Angular elements:

<center>

| Element   |                 Status                  |
| --------- | :-------------------------------------: |
| Component |      :white_check_mark: Supported       |
| Directive | :construction_worker: Not yet supported |
| Pipe      | :construction_worker: Not yet supported |

</center>

## Installation

Install `ng-vs-snippets` as a dev-dependency in your Angular project. To do so, run:

```
npm i @roguib/ng-vs-snippets --save-dev
```

Create a `package.json` script to extract snippets from your codebase:

```json
"scripts": {
    "ng-vs-snippets": "ng-vs-snippets --dir . --output ./.vscode",
},
```

Execute the script by running:

```
npm run ng-vs-snippets
```

The script will generate a `out.code-snippets` file containing all the definitions. **Make sure you don't have any file with the same name** since the data contained in that file **is going to be replaced**.

## Troubleshooting

Sometimes, due to VS Code configuration issues, snippets don't appear in the suggestion's dropdown. Make sure to specify, in VS Code `settings.json` configuration file the following properties:

```json
"editor.tabCompletion": "on",
"editor.snippetSuggestions": "top"
```

If this doesn't fix the problem, open the command palette and search for `Preferences: Configure User Snippets` to ensure the editor is considering the fille where your generated snippets are defined.

## Documentation

You can find the [full document design at this url]().

## Contributing

Pull requests are welcome :) Make sure to create an issue first so anyone's work is overlaped.
npm package: @rohaavi/commitai
Description: CommitAI — AI-powered conventional commit message generator for developers.
Author: Rohan Raj
Latest version: 1.0.0

# 🚀 CommitAI CLI  
### AI-powered, conventional commit message generator for developers.

CommitAI automatically generates clean, meaningful, conventional commit messages by analyzing your staged Git changes.  
Stop wasting time thinking about commit messages — let AI handle it.

---

## 📦 Installation

npm install -g @rohaavi/commitai


Requires Node.js 18+.

🔑 Login (via GitHub)
Before generating commits, authenticate using GitHub OAuth:


commitai login
This will:

open GitHub login in your browser

authenticate your GitHub account

return a secure token to your CLI

store it at:


~/.commitai.json
✨ Generate Commit Messages
1️⃣ Stage your files:

git add .

2️⃣ Generate commit messages:

commitai commit
You will see something like:

💡 Commit Suggestions:

1. fix(api): improve error msg when token is missing
2. fix(api): add descriptive error msg for missing token
3. fix(api): enhance error handling on auth token failure

✔ Select your commit message:
After selection, CommitAI automatically runs:

git commit -m "<your message>"

📚 CLI Commands
Command	Description
commitai login	       Login with GitHub
commitai commit	       Generate commit messages


🔒 Daily Usage Limit
All users get 30 AI commits per day.

No billing

No paid plans

Resets at midnight (IST)

Prevents API abuse

When the limit is hit:

⛔ Daily limit reached (30/30)
Try again tomorrow.