open-index/open-npm huggingface dataset:
npm package: @ropescore/rulesets
Description: Collection of rulesets to calculate rope skipping results
Author: Svante Bengtson
Latest version: 0.16.1

# FlowScore Rulesets

[![codecov](https://codecov.io/gh/lyra-sports/rulesets/graph/badge.svg?token=4OQJQODHGR)](https://codecov.io/gh/lyra-sports/rulesets)

FlowScore rulesets provides a vast and open library of calculations for Rope
Skipping competition rules.

These rules are exposed on four different levels from this package:

- **Models**\
  A raw scoring model for a category or type of events, as defined by a specific
  rulebook. It is highly configurable and comes in two flavours:
  - **Competition Event Model**\
    These provide a set of judges with description of their input fields and
    calculations for their judge score. These models also provide functions to
    calculate an entry score, entry ranks, and descriptions of result- and
    preview (shown to the tabulator) tables.
  - **Overall Model**\
    These provide calculations to create ranks across several models, as well
    as descriptions of result tables.
- **Competition Events/Overalls**\
  This is a pre-configured model for a known competition event definition.
  There may be some configuration options still left available that are meant to
  be set on a per-competition level.
- **Rulesets**\
  This provides a filtered list of competition events and overalls relevant to a
  specific rulebook and version.

The scoring pipeline then goes as follows for a competition event:

1. (Configure your competition event model or use a pre-configured model)
2. Calculate every judge's score
3. Take the result of that calculation and calculate every entry's score
4. Take the result of that calculation and calculate the competition event's
   rankings.

For overalls the pipeline is somewhat similar:

1. (Configure your competition event and overall models or use pre-configured
   models)
2. Calculate every judge's score\
   (you can likely use cached results from your competition event pipeline)
3. Take the result of that calculation and calculate every entry's score\
   (also likely cached)
3. **Determine who have competed in all required events.**\
   This library provides utility functions for this step.
4. Take the result of that calculation and calculate each competition event's
   rankings. (This cannot be cached from the other pipeline)
5. Take the result of that ranking and calculate the overall rankings.
npm package: @ropg/uniqarray
Description: Array that will only ever hold unique values
Latest version: 1.0.1

> Array that will only ever hold unique values

# UniqArray

This package gives you a `UniqArray` class that does everything a regular `Array` does, except it will ignore it when you try to add any values that are already contained in it.

> Frustratingly, there's a ton of packages in the index that provide just a single function to remove duplicates and return the array. All equivalents of `let uniqueItems = [...new Set(items)]`. 
> This provides a convenient full-featured array where the duplicates never make it in, so you don't have to filter them out all the time. 

## Installation

```text
npm install @ropg/uniqarray --save
```

## Usage

```js
const UniqArray = require('@ropg/uniqarray');

let a = new UniqArray(1,2,3,2);
console.log(a);                         // UniqArray(3) [ 1, 2, 3 ]
a.push(4,1,2,5,2);
console.log(a);                         // UniqArray(5) [ 1, 2, 3, 4, 5 ]
a.unshift(4,1,0);
console.log(a);                         // UniqArray(6) [ 0, 1, 2, 3, 4, 5 ]
console.log(a.concat([1,3,2,6,2,7]));   // UniqArray(8) [ 0, 1, 2, 3, 4, 5, 6, 7 ]
```

## Limitations

Works for "scalar values" (such as numbers and strings), does not look inside objects (which includes arrays):

```js
a = new UniqArray()
a.push (1,2,3,1,{a:true},{a:true},[1,2],[1,2])
console.log(a);
// UniqArray(7) [ 1, 2, 3, { a: true }, { a: true }, [ 1, 2 ], [ 1, 2 ] ]
```

( If you need something that will also reject objects with the same contents, you may want [`node-unique-array`](https://www.npmjs.com/package/node-unique-array), although that doesn't have the same interface as a regular js array. )

## Code

There really isn't all that much to it. Feel free to copy code below to your own project instead of depending on this module if you prefer that.

```js
class UniqArray extends Array {
    constructor(...args) {
        super(...new Set(args));
    }
    push(...args) {
        for (const a of args) if (!this.includes(a)) super.push(a);
        return this.length;
    }
    unshift(...args) {
        for (const a of args.reverse()) if (!this.includes(a)) super.unshift(a);
        return this.length;
    }
    concat(...args) {
        let r = new UniqArray(...this);
        for (const a of args) r.push(a);
        return r;
    }
}

module.exports = UniqArray
```
npm package: @rophpad/deq
Description: A simple Vite serve tool with QR code support
Author: rophpad
Latest version: 1.0.3

# deq

`deq` is a simple **Vite dev server** wrapper that adds:  

- Automatic **QR code** generation to open your project on mobile devices  
- Optional **localtunnel** support for sharing your dev server online  
- Auto-reload support with a single key press  

It’s perfect for fast local development and testing across devices.

---

## 🚀 Installation

Install globally using your favorite package manager:

```bash
# npm
npm install @rophpad/deq

# pnpm
pnpm add @rophpad/deq

# yarn
yarn global add @rophpad/deq

# bun
bun add @rophpad/deq



## 🛠️ How to use it?

In your Vite project, open the package.json file.

In the "scripts" section, under the existing "dev": "vite" line, add:

"serve": "node node_modules/@rophpad/deq/bin/index.js"


## Test it using:

pnpm run serve