open-index/open-npm huggingface dataset:
npm package: @gmolaire/chessboardjs
Description: JavaScript chessboard widget
Author: Chris Oakman
Latest version: 1.0.0

# chessboard.js

chessboard.js is a JavaScript chessboard component. It depends on [jQuery].

Please see [chessboardjs.com] for documentation and examples.

## What is chessboard.js?

chessboard.js is a JavaScript chessboard component with a flexible "just a
board" API that

chessboard.js is a standalone JavaScript Chess Board. It is designed to be "just
a board" and expose a powerful API so that it can be used in different ways.
Here's a non-exhaustive list of things you can do with chessboard.js:

- Use chessboard.js to show game positions alongside your expert commentary.
- Use chessboard.js to have a tactics website where users have to guess the best
  move.
- Integrate chessboard.js and [chess.js] with a PGN database and allow people to
  search and playback games (see [Example 5000])
- Build a chess server and have users play their games out using the
  chessboard.js board.

chessboard.js is flexible enough to handle any of these situations with relative
ease.

## What can chessboard.js **not** do?

The scope of chessboard.js is limited to "just a board." This is intentional and
makes chessboard.js flexible for handling a multitude of chess-related problems.

This is a common source of confusion for new users. [remove?]

Specifically, chessboard.js does not understand anything about how the game of
chess is played: how a knight moves, whose turn is it, is White in check?, etc.

Fortunately, the powerful [chess.js] library deals with exactly this sort of
problem domain and plays nicely with chessboard.js's flexible API. Some examples
of chessboard.js combined with chess.js: [Example 5000], [Example 5001], [Example 5002]

Please see the powerful [chess.js] library for an API to deal with these sorts
of questions.


This logic is distinct from the logic of the board. Please see the powerful
[chess.js] library for this aspect of your application.



Here is a list of things that chessboard.js is **not**:

- A chess engine
- A legal move validator
- A PGN parser

chessboard.js is designed to work well with any of those things, but the idea
behind chessboard.js is that the logic that controls the board should be
independent of those other problems.

## Docs and Examples

- Docs - <http://chessboardjs.com/docs>
- Examples - <http://chessboardjs.com/examples>

## Developer Tools

```sh
# create a build in the build/ directory
npm run build

# re-build the website
npm run website
```

## License

[MIT License](LICENSE.md)

[jQuery]:https://jquery.com/
[chessboardjs.com]:http://chessboardjs.com
[chess.js]:https://github.com/jhlywa/chess.js
[Example 5000]:http://chessboardjs.com/examples#5000
[Example 5001]:http://chessboardjs.com/examples#5001
[Example 5002]:http://chessboardjs.com/examples#5002
npm package: @gmolnar/react-native-android-sms-listener
Description: Allows you to listen for incoming SMS messages
Author: Andrey K. Vital
Latest version: 0.7.0

## `react-native-android-sms-listener` [![react-native-android-sms-listener](https://badge.fury.io/js/react-native-android-sms-listener.svg)](https://badge.fury.io/js/react-native-android-sms-listener)
An utility that allows you to listen for incoming SMS messages.

### Example
```JS
import SmsListener from 'react-native-android-sms-listener'

SmsListener.addListener(message => {
  console.info(message)
})
```

The contents of `message` object will be:
```JS
{
  originatingAddress: string,
  body: string
}
```

`SmsListener#addListener` returns a `CancellableSubscription` so if you want to stop listening for incoming SMS messages you can simply `.remove` it:

```JS
let subscription = SmsListener.addListener(...)

subscription.remove()
```

##### Example of using it for verification purposes:
...and if in your sign up process you have the phone number verification step which is done by sending a code via SMS to the specified phone, you might want to verify it automatically when the user receive it &mdash; pretty much like what Telegram or WhatsApp does:

```JS
let subscription = SmsListener.addListener(message => {
  let verificationCodeRegex = /Your verification code: ([\d]{6})/

  if (verificationCodeRegex.test(message.body)) {
    let verificationCode = message.body.match(verificationCodeRegex)[1]

    YourPhoneVerificationApi.verifyPhoneNumber(
      message.originatingAddress,
      verificationCode
    ).then(verifiedSuccessfully => {
      if (verifiedSuccessfully) {
        subscription.remove()
        return
      }

      if (__DEV__) {
        console.info(
          'Failed to verify phone `%s` using code `%s`',
          message.originatingAddress,
          verificationCode
        )
      }
    })
  }
})
```

If you're using Twilio or a similar third-party messaging service which you have a fixed phone number to deliver messages you might want to ensure that the message comes from your service by checking `message.originatingAddress`.

### Installation
```SH
$ npm install --save react-native-android-sms-listener
$ react-native link react-native-android-sms-listener
```

### Manual Installation
For a manual installation, all you need to do to use this so-called utility is:

*android/settings.gradle*
```Gradle
include ':react-native-android-sms-listener'
project(':react-native-android-sms-listener').projectDir = new File(rootProject.projectDir,'../node_modules/react-native-android-sms-listener/android')
```

*android/app/build.gradle*
```Gradle
dependencies {
  compile project(':react-native-android-sms-listener')
  // (...)
}
```

*MainApplication.java*
```Java
import com.centaurwarchief.smslistener.SmsListenerPackage;
```

```Java
@Override
protected List<ReactPackage> getPackages() {
  return Arrays.<ReactPackage>asList(
    new MainReactPackage(),
    new SmsListenerPackage()
    // (...)
  );
}
```
npm package: @gmonaco/react-dom
Description: React package for working with the DOM.
Latest version: 17.0.7

# `react-dom`

This package serves as the entry point to the DOM and server renderers for React. It is intended to be paired with the generic React package, which is shipped as `react` to npm.

## Installation

```sh
npm install react react-dom
```

## Usage

### In the browser

```js
var React = require('react');
var ReactDOM = require('react-dom');

function MyComponent() {
  return <div>Hello World</div>;
}

ReactDOM.render(<MyComponent />, node);
```

### On the server

```js
var React = require('react');
var ReactDOMServer = require('react-dom/server');

function MyComponent() {
  return <div>Hello World</div>;
}

ReactDOMServer.renderToString(<MyComponent />);
```

## API

### `react-dom`

- `findDOMNode`
- `render`
- `unmountComponentAtNode`

### `react-dom/server`

- `renderToString`
- `renderToStaticMarkup`
npm package: @gmoonc/app
Description: Goalmoon Ctrl (gmoonc) dashboard app package: routes, pages, and layout.
Latest version: 0.0.3

# @gmoonc/app

Complete pluggable dashboard app kit for React Router v6. Provides a full-featured dashboard with authentication pages, management interfaces, and a responsive layout.

## Installation

```bash
npm install @gmoonc/app
```

## CSS Import

Import the required CSS files in your entry point:

```javascript
import "@gmoonc/ui/styles.css";
import "@gmoonc/app/styles.css";
```

## Usage

There are two ways to integrate gmoonc routes into your React Router setup:

### A) Data Router (createBrowserRouter)

Use `createGmooncRoutes` to get `RouteObject[]` and spread into your router:

```tsx
import { createBrowserRouter, RouterProvider } from 'react-router-dom';
import { createGmooncRoutes } from '@gmoonc/app';

const router = createBrowserRouter([
  ...createGmooncRoutes({ basePath: "/app" }),
  // ... your other routes
]);

function App() {
  return <RouterProvider router={router} />;
}
```

### B) BrowserRouter (Routes/Route)

Use the `GmooncRoutes` component inside your `<Routes>`:

```tsx
import { BrowserRouter, Routes } from 'react-router-dom';
import { GmooncRoutes } from '@gmoonc/app';

function App() {
  return (
    <BrowserRouter>
      <Routes>
        <GmooncRoutes basePath="/app" />
        {/* Your other routes */}
      </Routes>
    </BrowserRouter>
  );
}
```

### Important: No Root Path Conflicts

**The gmoonc app kit never creates a route with `path="/"`.** The dashboard is always nested under `basePath` (default: `/app`). This ensures your app's root route remains available for your own pages.

- Dashboard routes are always under `basePath` (e.g., `/app`, `/dashboard`)
- Home page uses an index route (no explicit path)
- Auth routes are separate and don't interfere with your root path

### Customization

You can customize routes with `filter` and `map` props if needed:

```tsx
<GmooncRoutes
  basePath="/app"
  filter={(route) => route.path !== '/login'} // Exclude login route
  map={(route) => ({
    ...route,
    path: route.path?.replace('/app', '/dashboard') // Customize paths
  })}
/>
```

## Features

- **Complete App Kit**: Full dashboard with all pages and components
- **Auth Pages**: Login, Register, Forgot Password, Reset Password, Logout
- **Dashboard Pages**: 
  - Home (index route)
  - Admin → Permissions
  - Technical → Messages
  - Customer → Messages
- **Components**: Permissions Manager, Messages Manager, User Profile
- **Layout**: Integrated shell with menu and navigation
- **Session Management**: Mock session context (ready for real auth integration)
- **Responsive**: Mobile-first design with full responsiveness

## Note

Auth is currently mocked for UI development. Replace the session context with your real authentication system when ready.

## License

MIT
npm package: @gmoonc/cli
Description: CLI do Goalmoon Ctrl (gmoonc): instalador e configurador.
Latest version: 0.0.6

# @gmoonc/cli

CLI do Goalmoon Ctrl (gmoonc): install and configure @gmoonc/app in React projects.

## Installation

```bash
npm install @gmoonc/cli
```

## Usage

Run the default command to install and configure @gmoonc/app:

```bash
npx gmoonc
```

The default command will:

1. **Detect your project**: Verify `package.json` exists and identify package manager (npm/pnpm/yarn)
2. **Install dependencies**: Add `@gmoonc/app@^0.0.2` (which includes `@gmoonc/ui` and `@gmoonc/core`) and `react-router-dom@^6.0.0` if needed
3. **Find entrypoint**: Look for `src/main.tsx`, `src/main.jsx`, `src/main.ts` or `src/main.js`
4. **Inject CSS**: Add CSS imports to your entrypoint:
   ```ts
   import "@gmoonc/ui/styles.css";
   import "@gmoonc/app/styles.css";
   ```
5. **Integrate routes**: Automatically detect and patch React Router:
   - **Data Router** (createBrowserRouter): Adds `...createGmooncRoutes({ basePath })` to router array
   - **BrowserRouter**: Adds `<GmooncRoutes basePath="..." />` as first child of `<Routes>`

### Options

- `--yes` / `-y`: Skip confirmations and install automatically
- `--base <path>`: Base path for dashboard routes (default: `/app`)
- `--skip-router-patch`: Skip automatic router integration (only install and inject CSS)
- `--dry-run`: Show what would be done without making changes

### Examples

```bash
# Default setup with base path /app
npx gmoonc

# Custom base path
npx gmoonc --base /dashboard

# Skip router integration
npx gmoonc --skip-router-patch

# Dry run (see what would be done)
npx gmoonc --dry-run

# Skip confirmations
npx gmoonc --yes
```

### Manual Integration

If automatic router integration is not possible, the CLI will print minimal instructions:

**For Data Router (createBrowserRouter):**
- Import `createGmooncRoutes` from `@gmoonc/app`
- Add `...createGmooncRoutes({ basePath: "/app" })` to your router array

**For BrowserRouter:**
- Import `GmooncRoutes` from `@gmoonc/app`
- Add `<GmooncRoutes basePath="/app" />` as the first child of `<Routes>`

**Always ensure CSS imports are present in your entrypoint:**
- `import "@gmoonc/ui/styles.css";`
- `import "@gmoonc/app/styles.css";`

## Requirements

- Node.js 18+
- Existing React project with `package.json`
- Entrypoint in `src/main.*` (tsx, jsx, ts or js)

## Security

- Existing files are automatically backed up before modification
- Backup format: `file.gmoonc.bak-YYYYMMDDTHHMMSS.ext`
- CSS imports are not duplicated if they already exist

## Site

https://gmoonc.com
npm package: @gmoonc/core
Description: Core do Goalmoon Ctrl (gmoonc): config, tipos e utilitários agnósticos para dashboard/RBAC.
Latest version: 0.0.1

# @gmoonc/core

Core do Goalmoon Ctrl (gmoonc): tipos e helpers agnósticos para configurar menu e RBAC.

Instalação:
npm i @gmoonc/core

Exemplo:
import { defineConfig } from "@gmoonc/core";

export const config = defineConfig({
  appName: "Meu Dashboard",
  menu: [
    { id: "home", label: "Home", path: "/" },
    { id: "admin", label: "Admin", path: "/admin", roles: ["admin"] }
  ]
});

Site:
https://gmoonc.com
npm package: @gmoqa/paranoia
Description: HTTP request signature verifier middleware for node.js
Author: Guillermo Quinteros
Latest version: 1.0.0

# paranoia

HTTP request signature verifier middleware for express.js

## Usage

```js
const express = require('express');
const paranoia = require('paranoia');

const app = express();

app.use(paranoia(process.env.SECRET))
```
npm package: @gmoreyra/dynamic-data-table
Description: A DataTable for Angular 6, with dynamic columns and dynamic forms for CRUD operations. It uses Material Design components.
Author: Gabriel Moreyra
Latest version: 0.0.4

# DynamicDataTable

A DataTable for Angular 6, with dynamic columns and dynamic forms for CRUD operations. It uses Material Design components.

### Prerequisites

This library uses Angular Material. You can follow this guide to install it:

https://material.angular.io/guide/getting-started

### Installation and usage

You can install the package with the following command:

```
npm i -s @gmoreyra/dynamic-data-table
```

Import DynamicDataTableModule in your AppModule

```
import { DynamicDataTableModule } from '@gmoreyra/dynamic-data-table';

@NgModule({
  imports: [
    DynamicDataTableModule
  ]
})
```

Use the following directive:

```
<gm-data-table [data]="myData"></gm-data-table>
```

## Documentation

Work in progress...

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details