open-index/open-npm huggingface dataset:
npm package: @ludeng/test-vc
Description: ## Project setup
Author: WsZhu
Latest version: 1.1.1

# test-vc

## Project setup

```
yarn install
```

### Compiles and hot-reloads for development

```
yarn serve
```

### Compiles and minifies for production

```
yarn build
```

### Run your unit tests

```
yarn test:unit
```

### Lints and fixes files

```
yarn lint
```

### local component test

在组件库执行命令挂在全局
在引入组件的项目执行命令挂在依赖

```
npm link
```

### Customize configuration

See [Configuration Reference](https://cli.vuejs.org/config/).
npm package: @ludens-reklame/preserve
Description: A handy localstorage util
Latest version: 2.0.8

# Preserve

A state lib for keeping track of and change localStorage data

[![Build Status](https://travis-ci.org/ludens-reklamebyra/preserve.svg?branch=master)](https://travis-ci.org/ludens-reklamebyra/preserve) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

## Install

```sh
 npm install @ludens-reklame/preserve
```

or with Yarn

```sh
yarn add @ludens-reklame/preserve
```

## Basic usage

```ts
import preserve from '@ludens-reklame/preserve';

// Make an item you want to keep track of.
const myItem = preserve('myData');

// Get the current data from localStorage
myItem.get();

// Update the localStorage data.
myItem.set(2);

// Listen to changes that happens within your localStorage item
myItem.subscribe(nextData => {
  console.log(nextData); // 2
});

// Clear the item from localStorage
myItem.clearItem();
```
npm package: @ludens-reklame/vasadu
Description: Makes your localization life a breeze
Author: Øyvind Hermansen
Latest version: 0.1.3

# Vasadu

Makes your localization life a breeze!

## Install

```sh
yarn add @ludens-reklame/vasadu
```

## Usage

```ts
import Vasadu from '@ludens-reklame/vasadu';

// Define your translation tree
const myLocalizationTheme = {
  buttonText: {
    publish: {
      en: 'Publish',
      no: 'Publiser'
    }
  },
  intro: {
    en: 'Welcome to our site',
    no: 'Velkommen til vår side'
  }
};

// Initialize Vasadu class, and giving it our theme and wanted locale.
const localization = new Vasadu(myLocalizationTheme, 'no');

// Now we can access deep nested values with completed translations:
localization.si('buttonText.publish'); // Publiser
```

## Contribute

If you want to contribute in any way, feel free to create issues, or send pull requests!

# vasadu
npm package: @ludeschersoftware/math
Description: A modern, modular math toolkit for TypeScript and JavaScript, built for clarity, precision, and performance.
Author: Johannes Ludescher
Latest version: 1.0.0

A lightweight, zero-dependency math utility library for TypeScript and JavaScript — starting simple, scaling smart.

Whether you're building games, crunching data, or just need a reliable random number generator, this package is designed to be clean, fast, and developer-friendly. It’s the beginning of a modular math toolkit that grows with your needs.

---

### ✨ Features

- 🎲 `randomInt(min, max)` — Generate a random integer between two bounds (inclusive)
- 🧠 Type-safe and framework-agnostic
- 🪶 Lightweight and tree-shakable
- 📦 Ready for expansion: vectors, geometry, number theory, and more

---

### 📦 Installation

```bash
npm install @ludeschersoftware/math
# or
yarn add @ludeschersoftware/math
```

---

### 🔧 Usage

```ts
import { randomInt } from '@ludeschersoftware/math';

const roll = randomInt(1, 6);
console.log(`You rolled a ${roll}`); // → e.g., "You rolled a 4"
```

---

### 📐 Function Reference

#### `randomInt(min: number, max: number): number`

Returns a random integer between `min` and `max`, inclusive.

- ✅ Inclusive of both bounds
- ⚠️ Assumes `min ≤ max`
- 🧪 Uses `Math.random()` internally

```ts
randomInt(0, 10); // → 0 to 10
randomInt(100, 200); // → 100 to 200
```

---

### 🧱 Roadmap

This package is just getting started. Planned additions include:

- `clamp`, `lerp`, `roundTo`
- `Vector2`, `Vector3`, matrix operations
- Geometry helpers: distance, angle, collision
- Seeded random, noise generators
- Number theory: GCD, LCM, modular arithmetic

Want to contribute or suggest a feature? Open an issue or drop a pull request!

---

### 🧼 License

MIT © Johannes Ludescher

---

### 💬 Feedback & Contributions

This is just the beginning. If you’ve got ideas, improvements, or want to help shape the future of `@ludeschersoftware/math`, your input is more than welcome.
npm package: @ludeschersoftware/ref
Description: A Minimal Mutable Reference Wrapper for JavaScript
Author: Johannes Ludescher
Latest version: 1.0.0

# 🔗 Ref

A minimal, type-safe mutable reference wrapper for JavaScript and TypeScript.

`Ref` provides a simple way to encapsulate and mutate values without losing type safety. Inspired by reactive programming patterns, it's perfect for managing shared state, building custom reactive systems, or simplifying value tracking in functional code.

---

## 🚀 Features

- ✅ Generic type support (`Ref<T>`)
- 🔄 Mutable `.value` property for easy get/set
- 🧠 Great for state containers, observers, and dependency injection
- 🪶 Lightweight and framework-agnostic

---

## 📦 Installation

```bash
npm install @ludeschersoftware/ref
# or
yarn add @ludeschersoftware/ref
```

---

## 🧪 Usage

```ts
import { Ref } from '@ludeschersoftware/ref';

const count: Ref<number> = new Ref(0);

// Access the value
console.log(count.value); // 0

// Update the value
count.value += 1;
console.log(count.value); // 1
```

---

## 🛠️ API

### `Ref<T>`

A generic class that wraps a value of type `T`.

#### Constructor

```ts
new Ref<T>(initialValue: T)
```

#### Properties

- `value: T` – Get or set the current value.

---

## 🧩 Use Cases

- Shared mutable state across functions
- Custom reactive systems
- Dependency injection containers
- Functional programming with controlled mutability

---

## 📚 Example: Counter

```ts
function createCounter(): Ref<number> {
  const counter = new Ref(0);
  setInterval(() => counter.value++, 1000);
  return counter;
}

const myCounter = createCounter();
setTimeout(() => console.log(myCounter.value), 3000); // ~3
```

---

## 🧼 License

MIT © Johannes Ludescher

---

## 💬 Feedback

Got ideas or improvements? Feel free to open an issue or submit a PR. Contributions are welcome!
npm package: @ludeschersoftware/result
Description: A minimal JavaScript implementation of Rust's `Result<T, E>` type for expressive and safe error handling.
Author: Johannes Ludescher
Latest version: 1.0.0

A minimal JavaScript implementation of Rust's `Result<T, E>` type for expressive and safe error handling.

## ✨ Features

- `Result.Ok(value)` and `Result.Err(error)` constructors
- `isOk()` / `isErr()` type guards
- `unwrap()` / `unwrapErr()` for accessing values
- `map()` / `mapErr()` for transforming results
- No dependencies, fully portable

---

## 📦 Installation

```bash
npm install @ludeschersoftware/result
# or
yarn add @ludeschersoftware/result
```

## 🚀 Usage

```javascript
import Result from "@ludeschersoftware/result";

const result = parseNumber("42");

if (result.isOk()) {
  console.log("Parsed:", result.unwrap());
} else {
  console.error("Failed:", result.unwrapErr());
}

function parseNumber(str) {
  const num = Number(str);
  return isNaN(num) ? Result.Err("Not a number") : Result.Ok(num);
}
```

## 🧠 API

| Method         | Description                                      |
|----------------|--------------------------------------------------|
| `Result.Ok(val)` | Creates a success result                       |
| `Result.Err(err)` | Creates an error result                       |
| `isOk()`       | Returns `true` if result is Ok                   |
| `isErr()`      | Returns `true` if result is Err                  |
| `unwrap()`     | Returns value if Ok, throws if Err               |
| `unwrapErr()`  | Returns error if Err, throws if Ok               |
| `map(fn)`      | Transforms Ok value, passes Err through          |
| `mapErr(fn)`   | Transforms Err value, passes Ok through          |

---

## 🧼 License

MIT © Johannes Ludescher

---

## 💬 Feedback

Got ideas or improvements? Feel free to open an issue or submit a PR. Contributions are welcome!
npm package: @ludeschersoftware/ticktock
Description: A lightweight utility for delaying function execution with ease. TickTock wraps your callback and ensures it only runs after a pause, perfect for debouncing rapid events like keystrokes, window resizing, or API calls. Simple, effective, and ready to run.
Author: Johannes Ludescher
Latest version: 1.0.1

# ⏳ TickTock

**A lightweight utility for delaying function execution with ease.**  
TickTock wraps your callback and ensures it only runs after a pause, perfect for debouncing rapid events like keystrokes, window resizing, or API calls. Simple, effective, and ready to run.

---

## 🚀 Installation

```bash
npm install @ludeschersoftware/ticktock
```

or

```bash
yarn add @ludeschersoftware/ticktock
```

---

## 📦 Usage

```ts
import TickTock from "@ludeschersoftware/ticktock";

const debouncedLog = new TickTock((msg: string) => {
  console.log("Debounced:", msg);
}, 1000); // Delay in milliseconds

debouncedLog.run("Hello");
debouncedLog.run("Hello again"); // Only this will be logged after 1 second
```

---

## 🧠 API

### `new TickTock(callback: (...args: any[]) => void, delay?: number)`

- `callback`: Function to execute after the delay
- `delay`: Optional delay in milliseconds (default: `500`)

### `.run(...args: any[])`

- Triggers the debounced execution of the callback with the provided arguments.

---

## 🛠️ Development

```bash
npm run build     # Compile TypeScript
npm run watch     # Watch for changes
```

---

## 📄 License

MIT © [Johannes Ludescher](https://github.com/ludescher)

---

## 🐛 Issues

Found a bug or have a feature request? [Open an issue](https://github.com/ludescher/JTickTock/issues)