open-index/open-npm huggingface dataset:
npm package: @racedayready/workouts
Description: Workout schemas, types and utilities.
Latest version: 0.1.11

# @racedayready/workouts

Shared workout schemas, types and utilities used by RDR and benchmarking tools.

## Releasing

This repo publishes from GitHub Actions when a new version is released.

### Release steps

1. Run checks locally:

- `npm ci`
- `npm run release:check`

2. Bump version and create a tag:

- `npm version patch` (or `minor` / `major`)

3. Update the `CHANGELOG.md`
4. Open a PR with the changes and merge
5. Create a new release

- Tag version `vX.Y.Z`
- Release title `Workouts vX.Y.Z`
- Paste the content from `CHANGELOG.md` into the description

The `publish.yml` workflow will automatically publish the new version to npm upon new release publish.
npm package: @racedirector/iracing-socket-js
Description: iRacingBrowserApps/Kapps socket adpater for iRacing
Latest version: 2.0.0

### Usage
#### iRacingBrowserApps
1) Install iRacingBrowserApps
2) Start `server.exe`

#### Kapps
1) Start kapps

### Example
#### Create a socket
```ts
import {iRacingSocket} from 'iracing-socket-js'

const socket: iRacingSocket = new iRacingSocket({
  server,
  fps,
  requestParameters,
  requestParametersOnce,
})
.on(iRacingSocketEvents.SocketConnect, () => setSocketConnected(true))
.on(iRacingSocketEvents.SocketDisconnect, () => setSocketConnected(false))
.on(iRacingSocketEvents.Connect, () => setIRacingConnected(true))
.on(iRacingSocketEvents.Disconnect, () => setIRacingConnected(false))
.on(iRacingSocketEvents.Update, () => setData({...newSocket.data}));
```
#### Create a socket consumer (taken from `src/flagObserver.ts`)
```ts
import {iRacingSocketConsumer, Flags} from "iracing-socket-js";

export const IRACING_REQUEST_PARAMS: string[] = ["SessionFlags", "SessionTime", "SessionTimeOfDay"];

export enum FlagsObserverEvents {
  FlagChange = "flagChange",
}

export class FlagsObserver extends iRacingSocketConsumer {
  private previousFlags: Flags;

  onUpdate = (keys: string[]) => {
    if (!keys.includes("SessionFlags")) {
      return;
    }

    const {
      SessionFlags: flags = -1,
      SessionTime: sessionTime,
      SessionTimeOfDay: sessionTimeOfDay,
    } = this.socket.data;

    if (flags !== this.previousFlags) {
      this.emit(
        FlagsObserverEvents.FlagChange,
        this.previousFlags,
        flags,
        sessionTime,
        sessionTimeOfDay,
      );

      this.previousFlags = flags as Flags;
    }
  };
}

export default FlagsObserver;

```
#### Connect the socket observer to the socket
```ts
const flagObserver = new FlagObserver(socket)
// !!!: Or, pass the options for creating a new socket directly to the socket consumer:
const flagObserver = new FlagObserver({
  server,
  fps,
  requestParameters,
  requestParametersOnce,
})

flagObserver.on(FlagObserverEvents.FlagChange, (previousFlags, nextFlags, sessionTime, sessionTimeOfDay) => {
  console.log("Do something with the change event!?")
})
```

### React Extensions
#### IRacingProvider
You must wrap your application in `IRacingProvider` to have access to the hooks.
```ts
const socket = new iRacingSocket({
  server: "localhost:1234",
  requestParameters: ["DriverInfo"],
});

const App: React.FC<{}> = ({children}) => (
  <IRacingProvider socket={socket}>
    {children}
  </IRacingProvider>
)
```
#### useIRacingSocket
```ts
const SocketConsumingComponent: React.FC<{}> = ({children}) => {
  const socket = useIRacingSocket()

  // TODO: Do something with the socket
  useEffect(() => {
    const updateEventHandler = (keys) => {
      console.log("Socket did update keys:", keys)
    }

    socket.on(iRacingSocketEvents.Update, updateEventHandler)

    return () => {
      socket.removeEventListener(iRacingSocketEvents.Update, updateEventHandler)
    }
  }, [socket])
} 
```

#### useIRacingSocketConnectionState

#### useIRacingSocketParameters
npm package: @racehorse/react
Description: React hooks for Racehorse.
Author: Savva Mikhalevski
Latest version: 1.10.1

# React integration for Racehorse

Hooks that integrate [Racehorse](https://github.com/smikhalevski/racehorse#readme) into a React app.

```sh
npm install --save-prod @racehorse/react
```
npm package: @racehub-io/f1game-udp-parser
Description: Rust built Node compatible udp parser for Codemaster's Formula 1 games
Author: msansoni
Latest version: 0.4.12

# F1 Game UDP Parser
![npm (scoped)](https://img.shields.io/npm/v/@racehub-io/f1game-udp-parser?style=for-the-badge)
![GitHub](https://img.shields.io/github/license/racehub-io/f1game-udp-parser?style=for-the-badge)

## Installing
### Important!
**This is a native node module written in [Rust](https://www.rust-lang.org/install.html). To allow for cross compatibility it builds from source on installation.**
You will require Rust installed, before installing this module.
As soon as [Neon](https://neon-bindings.com/) is stable enough to compile through node-gyp for compiled releases we will migrate.


```
$ npm install @racehub-io/f1game-udp-parser
```

or

```
$ yarn add @racehub-io/f1game-udp-parser
```

## Usage

```
import { TelemetryClient, constants } from "@racehub-io/f1game-udp-parser";
// or: const { TelemetryClient, constants } = require('f1game-udp-parser');
const { DATA } = constants;

const client = new TelemetryClient({port: 20777, forwardAddresses: [{port:30500}]});
client.on(DATA, (packetVersion, packetType, packetData) => console.log(packetData));

client.start();

// and when you want to stop:
client.stop();
```

## ToDo
- [ ] Migrate publishing to node-gyp for compiled builds
- [ ] Move UDP socket and EventEmitter to Rust
- [ ] Improve packet dependent logic inside Rust parser
- [ ] Migrate to N-API backend with Neon
- [ ] Update Rust dependencies
npm package: @racejs/compat
Description: ⚡️ Express 4.x compatibility layer for RaceJS
Author: Dhananjay Latpate
Latest version: 1.0.1

# @express/compat

Express 4.x compatibility layer for `@express/core`.

## Installation

```bash
npm install @express/compat
```

## Usage

Drop-in replacement for Express 4.x:

```javascript
// Before (Express 4.x)
const express = require('express');
const app = express();

// After (@express/compat)
import express from '@express/compat';
const app = express();
```

## What's Included

### ✅ Fully Compatible

- `app.get/post/put/delete/patch()`
- `app.all()`
- `app.use()`
- `app.listen()`
- `app.set/get()` for settings
- `app.enable/disable()`
- `app.enabled/disabled()`
- `req.params`
- `req.query`
- `req.get()`
- `res.json()`
- `res.send()`
- `res.status()`
- `res.redirect()`
- `res.cookie()`
- `res.clearCookie()`

### ⚠️ Partially Compatible

- `express.static()` - Logs warning, use `serve-static` instead
- `res.sendFile()` - Logs warning, use `send` package
- `res.download()` - Logs warning, use `send` package
- `app.render()` - Logs warning, use external template engine
- `app.engine()` - Logs warning, use external template engine
- `app.param()` - Logs warning, not supported

### ❌ Not Supported

- Sub-applications (`app.use('/prefix', subApp)`)
- View engines
- Some advanced response methods

## Example

```javascript
import express from '@express/compat';

const app = express();

// Works like Express 4.x
app.set('trust proxy', true);
app.enable('case sensitive routing');

app.get('/', (req, res) => {
  res.json({ message: 'Hello from @express/compat!' });
});

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

## Performance

While `@express/compat` provides compatibility, you'll get better performance using `@express/core` directly:

| Package | RPS | Performance |
|---------|-----|-------------|
| Express 4.x | 24k | Baseline |
| @express/compat | 48k | +100% |
| @express/core | 52k | +117% |

The compatibility layer adds ~8% overhead compared to using `@express/core` directly.

## Migration Path

1. **Quick migration**: Use `@express/compat` for immediate benefits
2. **Gradual refactor**: Move to `@express/core` API over time
3. **Maximum performance**: Use `@express/core` directly

## Warnings

The compatibility layer will log warnings for unsupported features:

```
[Express Compat] app.engine() is not supported. Use external template engines.
[Express Compat] res.sendFile() not fully implemented.
```

These can be disabled:

```javascript
process.env.EXPRESS_COMPAT_SILENT = 'true';
```

## License

MIT
npm package: @racejs/core
Description: ⚡️ High-performance core engine for RaceJS framework
Author: Dhananjay Latpate
Latest version: 1.0.1

# @racejs/core

⚡️ High-performance core engine for RaceJS framework - An ultra-fast, Express-compatible Node.js web framework built for performance.

## Features

- 🚀 **Blazing Fast**: Optimized router and middleware system
- 🔄 **Hot Reload**: Smart hot reload with zero downtime (development & production)
- 🔌 **Express Compatible**: Drop-in replacement for Express 4.x (use with @racejs/compat)
- 📦 **Zero Dependencies**: Minimal footprint (optional: @parcel/watcher for better hot reload)
- 🎯 **Modern API**: Built with TypeScript, async/await first
- ⚙️ **Advanced Features**: Native file watching, route swapping, graceful shutdown

## Installation

```bash
npm install @racejs/core
```

## Quick Start

```javascript
import { createRaceApp } from '@racejs/core';

const app = createRaceApp();

app.get('/', (req, res) => {
  res.json({ message: 'Hello from RaceJS!' });
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});
```

## Hot Reload

Enable hot reload for zero-downtime development:

```javascript
import { createRaceApp } from '@racejs/core';

const app = createRaceApp({
  hotReload: {
    enabled: true,
    watch: ['./routes', './middleware'],
  },
});
```

## Documentation

- [Full Documentation](https://github.com/resillix/racejs#readme)
- [Hot Reload Guide](https://github.com/resillix/racejs/blob/master/docs/guides/HOT-RELOAD.md)
- [Migration Guide](https://github.com/resillix/racejs/blob/master/docs/migration.md)
- [Examples](https://github.com/resillix/racejs/tree/master/examples)

## Express Compatibility

For Express 4.x compatibility, use `@racejs/compat`:

```bash
npm install @racejs/compat
```

See [@racejs/compat](https://www.npmjs.com/package/@racejs/compat) for details.

## Performance

RaceJS delivers exceptional performance:

- **3-5x faster** routing than Express
- **Zero overhead** middleware system
- **Optimized** for modern Node.js (18+)

## License

MIT © [Resillix](https://github.com/resillix)

## Links

- [GitHub Repository](https://github.com/resillix/racejs)
- [Documentation](https://github.com/resillix/racejs#readme)
- [Issues](https://github.com/resillix/racejs/issues)
- [Contributing Guide](https://github.com/resillix/racejs/blob/master/CONTRIBUTING.md)
npm package: @racetrainer/passport-garmin
Description: Passport OAuth2 Strategy implementation for Garmin Connect
Author: Dylan Fiedler
Latest version: 0.0.8

# passport-garmin

A Passport OAuth2 strategy implementation for Garmin Connect OAuth2 endpoints.

## Overview

This package implements a Passport OAuth2 authentication strategy specifically configured for Garmin Connect's OAuth2 API. It extends the base `passport-oauth2` strategy with Garmin-specific endpoints and configuration.

## Installation

```bash
npm install @racetrainer/passport-garmin
```

## Usage

### Setting up the strategy

```typescript
import passport from 'passport';
import { Request, Response } from 'express';
import { GarminStrategy, type GarminProfile } from '@racetrainer/passport-garmin';

passport.use(new GarminStrategy({
  clientID: 'your-garmin-client-id',
  clientSecret: 'your-garmin-client-secret',
  callbackURL: 'http://localhost:3000/auth/garmin/callback', // must match the redirect URI in your Garmin developer portal
}, (accessToken: string, refreshToken: string, profile: GarminProfile, done: (error: any, user?: any) => void) => {
  // do any additional processing here, such as saving the user to a database
  return done(null, profile);
}));
```

### Authenticating Users

```typescript
import express, { Request, Response } from 'express';
import session from 'express-session';

const app = express();

// use session middleware
app.use(session({
  secret: 'your-secret-key',
  resave: false,
  saveUninitialized: true,
  cookie: { secure: false, httpOnly: true, sameSite: 'lax' },
}));

// Configure passport middleware
app.use(passport.initialize());
app.use(passport.session());

// initiate authentication to garmin
app.get('/auth/garmin', passport.authenticate('garmin'));

// handle callback from garmin with state stored in session data
app.get('/auth/garmin/callback', 
  passport.authenticate('garmin', { failureRedirect: '/error' }),
  (req: Request & { user: { profile: GarminProfile, accessToken: string, refreshToken: string, expiresAt: number } }, res: Response) => {
    // successful authentication, redirect to dashboard
    res.redirect('/dashboard');
  }
);

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});
```

## Documentation

For detailed information about Garmin's OAuth2 implementation, refer to the official documentation:
[Garmin OAuth2 PKCE Documentation](https://developerportal.garmin.com/sites/default/files/OAuth2PKCE_1.pdf)

## License

MIT