open-index/open-npm huggingface dataset:
npm package: @gamers-geek/djs-embed-builder
Description: A discord.js interactive embed builder for slash commands.
Author: Gamers-geek
Latest version: 3.0.0

<h1 align="center">djs-embed-builder (en Français)</h1>
<br>

Ce projet est une fork du projet initial de [@braxtongpoll/djs-embed-builder](https://github.com/braxtongpoll/djs-embed-builder)

## Utilisation
```js
const { Client } = require('discord.js');
const djs = require(`djs-embed-builder`);
const client = new Client();
client.embed = new djs(client).createEmbed

client.on("interactionCreate", (client, interaction) => {
    if (interaction.commandName == "embed") {
        client.embed(interaction);
    };
});

client.on("messageCreate", (client, message) => {
    let prefix = "+";
    let args = message.content.slice(prefix.length).trim().split(/ +/g);
    let command = args.shift().toLowerCase();
    if (command == "embed") {
        client.embed(message);
    };
});
```


## Dépendances 
* [Discord.js@13.1.0](https://npmjs.com/package/discord.js)

## Examples
Pour voir des examples, rendez-vous dans le fichier [examples.js](https://github.com/Gamers-geek/djs-embed-builder/blob/main/src/examples.js)

Le module est extrêmement simple à utiliser !

## Contact 
* [Discord](https://discord.gg/7ykdCWQGE6)
* [Github](https://github.com/Gamers-geek)
* [Website](https://gamers-geek.gq/)
npm package: @gamersclub/react-scripts
Description: Gamers Club Configuration and scripts for Create React App.
Latest version: 4.0.3-alpha.2

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.
npm package: @gamersclub/wasd-cli
Description: Gamers Club Wasd CLI
Latest version: 1.0.14

# Gamers Club Wasd CLI

CLI for optimize common developer actions

## How to use

Install globally with npm:

```bash
npm i -g @gamersclub/wasd-cli
```

See help overview

```bash
wasd --help
```

Generate a new project

```bash
wasd new <projectName>

// or

wasd -g project
```

Generate a new module

```bash
wasd -g module
```

Generate a new module duck

```bash
wasd -g duck
```

## Dev instructions

Install dependencies

```bash
npm i
```

Running

```bash
npm start
```

Publishing NPM package

```bash
npm login

npm publish
```
npm package: @gamertike/maths
Description: A light weight math module
Author: Gamertike
Latest version: 1.1.0
Deprecated: This version is unusable due to me forgeting to compile my typescript code

# @gamertike/maths
A light weight maths module.


# Usage

```js
import { add, subtract, multiply, divide } from '@gamertike/maths';

console.log(`Add: ${add(4, 6)}`); // Add: 10

console.log(`Subtract: ${subtract(10, 3)}`); // Subtract: 7

console.log(`Multiply: ${multiply(3, 3)}`); // Multiply: 9

console.log(`Divide: ${divide(10, 2)}`); // Divide: 5
```
npm package: @games-fun/react
Description: React bindings for the Games.fun SDK
Author: Games.fun
Latest version: 0.1.95

# @games-fun/react

React bindings and components for the Games.fun SDK.

## Installation

```bash
npm install @games-fun/react @games-fun/sdk
```

## Usage

### Provider Setup

Wrap your application or game component with the `GamesFunProvider`:

```jsx
import { GamesFunProvider } from '@games-fun/react';

function App() {
  return (
    <GamesFunProvider 
      options={{ 
        debug: true,
        gameServerUrl: 'your-game-server-url'
      }}
      onInitialized={(connection) => console.log('SDK initialized', connection)}
      onError={(error) => console.error('SDK error', error)}
    >
      <YourGame />
    </GamesFunProvider>
  );
}
```

### Using the SDK in Components

```jsx
import { useGamesFun, useGamesFunActions, ConnectionStatus } from '@games-fun/react';

function YourGame() {
  const { connection } = useGamesFun();

  // Register all game actions
  const actions = useGamesFunActions({
    purchaseItem: "Purchase in-game item",
    useItem: "Use inventory item",
    transferTokens: "Transfer tokens to game wallet"
  });

  const handlePurchase = async () => {
    try {
      await actions.purchaseItem({ 
        itemId: 'sword',
        price: 100,
      });
      console.log('Purchase successful');
    } catch (error) {
      console.error('Purchase failed:', error);
    }
  };

  return (
    <div>
      <h1>My Game</h1>
      
      {/* Built-in connection status component */}
      <ConnectionStatus />
      
      <button onClick={handlePurchase} disabled={!connection}>
        Buy Sword (100 coins)
      </button>
      
      {connection && (
        <div>
          <p>Token Balance: {connection.tokenBalance}</p>
          {connection.walletAddress && (
            <p>Wallet: {connection.walletAddress}</p>
          )}
        </div>
      )}
    </div>
  );
}
```

## API Reference

### Components

- `GamesFunProvider` - Context provider for the SDK
- `ConnectionStatus` - Component to display connection status

### Hooks

- `useGamesFun` - Access the SDK instance and connection
- `useGamesFunActions` - Register and trigger game actions
- `useGamesFunContext` - Direct access to the context (advanced usage)

## License

MIT
npm package: @games-fun/sdk
Description: Client SDK for integrating games with the Games.fun platform
Author: Games.fun
Latest version: 0.1.94

# Games.fun SDK

JavaScript SDK for integrating games with the Games.fun platform.

## Installation

```bash
npm install @games-fun/sdk
# or
yarn add @games-fun/sdk
# or
pnpm add @games-fun/sdk
```

## Quick Start

```javascript
import { GamesFunSDK } from '@games-fun/sdk';

// Initialize SDK
const sdk = new GamesFunSDK({
    debug: true,
    gameServerUrl: "your-game-server-url",
    onConnect: (connection) => {
        // Handle connection established
        console.log("Connected:", connection);
    }
});

// Register game actions
sdk.registerActions({
    purchaseItem: "Purchase in-game item",
    useItem: "Use inventory item"
});

// Trigger actions
try {
    const result = await sdk.triggerAction("purchaseItem", {
        itemId: "123",
        price: 100
    });
    console.log("Purchase successful:", result);
} catch (error) {
    console.error("Purchase failed:", error);
}
```

## Development Mode

For local development and testing, you can enable dev mode to simulate wallet connections and token balances:

```javascript
const sdk = new GamesFunSDK({
    debug: true,
    gameServerUrl: "your-game-server-url",
    dev: {
        enabled: true // Auto-connects wallet with mock data
    }
});
```

This will automatically:
- Connect a mock wallet
- Set initial token balances
- Enable auto-validation of actions

## API Reference

### `GamesFunSDK`

#### Constructor Options
```typescript
interface SDKOptions {
    debug?: boolean;
    gameServerUrl: string;
    onConnect?: (connection: Connection) => void;
    onBalanceUpdate?: (connection: Connection) => void;
    dev?: {
        enabled?: boolean;  // Auto-enabled if not in iframe
    }
}
```

#### Methods

- `registerActions(actions: Record<string, string>)`: Register multiple game actions
- `triggerAction(actionName: string, params: any)`: Trigger a game action
- `getConnection()`: Get current connection state

### Connection State

```typescript
interface Connection {
    privyId: string;
    gameId?: string;
    token?: string;
    walletAddress: string | null;
    tokenBalance: string;
    solBalance: string;
}
```

## Examples

Check out the [examples](../../examples) directory for:
- [Vanilla JavaScript](../../examples/vanilla)
- [React](../../examples/react-basic)

## Development

1. Install dependencies:
```bash
pnpm install
```

2. Build:
```bash
pnpm build
```

3. Watch mode:
```bash
pnpm dev
npm package: @gamesaucer/customiz3-core
Description: Zelda 3 ROM Customizer
Author: Gamesaucer
Latest version: 1.1.0

# CustomiZ3-Core

[![Build Status](https://travis-ci.org/gamesaucer/CustomiZ3-Core.svg?branch=master)](https://travis-ci.org/gamesaucer/CustomiZ3-Core) 
[![Coverage Status](https://coveralls.io/repos/github/gamesaucer/CustomiZ3-Core/badge.svg?branch=master)](https://coveralls.io/github/gamesaucer/CustomiZ3-Core?branch=master) [![NPM Version](https://img.shields.io/npm/v/@gamesaucer/customiz3-core)](https://www.npmjs.com/package/@gamesaucer/customiz3-core) [![Code Style: Standard](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Description

CustomiZ3 is a tool for customizing Zelda 3 roms. It relies fully on the contents of the provided rom, as most of its editing capability consists of pointing to other parts of the rom and copying over values.

The tool has an internal map of where to find certain game data, and by providing instructions, it becomes possible swap or copy the behaviour of things such as holes, bird locations and whirlpools to other objects of the same type.

## Installation

You can use Node package manager to install CustomiZ3.

```cmd
npm install @gamesaucer/customiz3-core
```

## Usage

Use CustomiZ3 in a project as follows:

```JavaScript
const CustomiZ3 = require('@gamesaucer/customiz3-core')
// or:
const { getPatcher, getRomVersion, getDomainList } = require('@gamesaucer/customiz3-core')
```

Retrieve the version data of a rom by calling `getRomVersion` and providing the path to the rom file:

```JavaScript
const version = await CustomiZ3.getRomVersion('path/to/rom')
```

Get a list of Domain objects for a set of changes by calling `getDomainList` and providing the changes:

```JavaScript
const domainList = await CustomiZ3.getDomainList(changes)
```

Get a PatcherFactory by calling `getPatcher` and providing the Domain list and the rom version. Then call the PatcherFactory with the desired type of patch to get a Patcher.

```JavaScript
const patcherFactory = await CustomiZ3.getPatcher(domainList, version)
const patcher = await patcherFactory('native')
```

Call the `patch` method on the Patcher with the path to the rom file and a target location:

```JavaScript
await patcher.patch('path/to/rom', 'path/to/target')
```

The target file will now be a copy of the rom, but with the changes applied to it.