open-index/open-npm huggingface dataset:
npm package: @kwo/http-errors
Description: ES6 Errors for HTTP Status Codes
Author: Karl Ostendorf
Latest version: 1.2.0
Deprecated: this package has been deprecated

# HTTP Errors

ES6 Errors for HTTP Status Codes

### Usage

An example using ExpressJS.


```
import {HttpError, MethodNotAllowed} from '@kwo/http-errors';

// only allow POST requests
router.use((req, res, next) => {
	if (req && req.method && req.method === 'POST')
		return next();
	next(new MethodNotAllowed());
});

...

// error handler
router.use((err, req, rsp, next) => {
	const CT_TEXT = 'text/plain; charset=utf-8';
	if (err) {
		if (err instanceof HttpError) {
			rsp.status(err.status).type(CT_TEXT).send(err.message);
		} else {
			next(err);
		}
	} else {
		next();
	}
});


```
npm package: @kwolfsanta/amtd
Description: React component library. Made to learn develope my own component library.
Author: evankwolf
Latest version: 0.1.1

## Introduction
My personal ant-design. This is only used for practice.

You can check the docs [here](https://evankwolf.github.io/amtd/)

## Tech Stack
- React
- Vite
- Typescript
- [Vitest](https://vitest.dev/) - A Blazing Fast Unit Test Framework
- [React Testing Library](https://testing-library.com/) - Test UI Components In a User-centric Way
- [Unocss](https://unocss.dev/) - The instant on-demand atomic CSS engine.
- Husky

## Install
```bash
pnpm install @kwolfsanta/amtd
```

## Usage

```tsx
import React, { useState } from 'react'

import { Button } from '@kwolfsanta/amtd'
import '@kwolfsanta/amtd/dist/es/style.css'

const HelloWorld = () => {
  const [count, setCount] = useState(0)

  const handleClick = () => {
    setCount(count + 1)
  }

  return (
    <div>
      <Button btnType="primary" onClick={handleClick}>Current count: {count}</Button>
    </div>
  )
}

```
npm package: @kwonjeong/react-palette-card
Description: A reusable pastel card component
Latest version: 0.1.0

# 🎨 react-palette-card

> A pastel gradient-style React card component

## ✨ Features

- Beautiful pastel gradient backgrounds
- Responsive size options: sm, md, lg with proportional scaling
- 7 color palette options
- Optional profile image support
- Toggleable shadow effect
- Rotation when hovering

## 📦 Installation

```bash
yarn add react-palette-card
# or
npm install react-palette-card
```

## 🧾 Props

| Name          | Type                         | Description                                         | Required |
| ------------- | ---------------------------- | --------------------------------------------------- | -------- |
| `title`       | `string`                     | Card title text (e.g., name, role)                  | ✅       |
| `description` | `string`                     | Card description (e.g., job, bio)                   | ✅       |
| `imageSrc`    | `string` (URL)               | URL or local path of profile image                  | ☑️       |
| `color`       | `'red'` \| `'orange'` \| ... | Background color palette ('blue' by default)        | ☑️       |
| `size`        | `'sm'` \| `'md'` \| `'lg'`   | Card size ('md' by default)                         | ☑️       |
| `shadow`      | `boolean`                    | Whether to apply a shadow effect (false by default) | ☑️       |

## 📂 Folder Structure

```bash
src/
┣ components/
┃ ┗ Card/
┃    ┣ Card.tsx
┃    ┣ Card.styles.ts
┃    ┣ Card.types.ts
┃    ┗ index.ts
┣ App.tsx
┣ main.tsx
```

## ✍🏻 Usage

```javascript
import { Card } from "react-palette-card";
import profile from "./assets/profile.png";

<Card
  title=""
  description=""
  imageSrc={profile}
  color="green"
  size="md"
  shadow
/>;
```

## 📄 License

[MIT](https://web.mit.edu/)

Feel free to use, share, and contribute!
npm package: @kwonlabs/openzl-wasm
Description: WebAssembly port of Meta's OpenZL (Structured Data Compression Framework)
Author: KwonMinchul Computer Labs, LLC.
Latest version: 0.2.0

# openzl-wasm

WebAssembly port of Meta's **OpenZL** (Structured Data Compression Framework).

## Overview

`openzl-wasm` provides high-performance, structure-aware data compression for Web and Node.js environments. By leveraging WebAssembly and Emscripten, it brings the power of Meta's [OpenZL](https://github.com/facebook/OpenZL) to the JavaScript ecosystem with minimal overhead and full type safety.

OpenZL is designed to achieve superior compression ratios and speeds by explicitly modeling data structures and patterns, making it ideal for columnar data, JSON-like structures, and repetitive datasets.

## Features

- **Blazing Fast**: Near-native compression and decompression speeds using optimized WASM binaries.
- **Structure-Aware**: Better compression ratios for structured data compared to general-purpose algorithms.
- **Universal**: Runs in modern browsers and Node.js.
- **Type-Safe**: First-class TypeScript support with comprehensive definitions.
- **Easy Integration**: Seamless integration with Bun and other modern package managers.

## Installation

```bash
bun add @kwonlabs/openzl-wasm
```

## Usage

### Basic Usage

```typescript
import { OpenZL } from '@kwonlabs/openzl-wasm';

// Check if ready (non-blocking)
if (OpenZL.isReady()) {
    console.log("OpenZL is ready!");
}

// Or wait for it to be ready
await OpenZL.load();
```

### Sync Usage (Blocking)

Sync calls require the module to be initialized. Use `await OpenZL.load()` before calling these if you aren't sure it's ready.

```typescript
// Data to compress (define once for all examples)
const data = new TextEncoder().encode(JSON.stringify({ 
  id: 1, 
  name: "OpenZL", 
  tags: ["compression", "wasm"] 
}));

// Compress
const compressed = OpenZL.compress(data);
console.log(`Original: ${data.length} bytes, Compressed: ${compressed.length} bytes`);

// Decompress
const decompressed = OpenZL.decompress(compressed);
const originalJson = new TextDecoder().decode(decompressed);
```

### Async Usage (Non-blocking & Auto-waiting)

Async versions will **automatically wait** for the module to load if it hasn't finished yet. You can call these immediately after import.

```typescript
// Compress Asynchronously (Auto-waits if loading)
const compressed = await OpenZL.compressAsync(data);

// Decompress Asynchronously
const decompressed = await OpenZL.decompressAsync(compressed);
```


## License

This project is licensed under the **MIT License**. See the [LICENSE](./LICENSE) file for details.

> [!NOTE]
> This project includes and links to **OpenZL**, which is developed by Meta and licensed under the **BSD 3-Clause License**. The original license is maintained within the submodule at `vendor/OpenZL/LICENSE`.
npm package: @kworq/x-api-post
Description: A Node.js module for posting tweets with media (images, videos, GIFs) to X (formerly Twitter) using the API. It handles authentication, media uploading, and posting tweets.
Author: Guy Peires
Latest version: 0.1.3

# X / Twitter Media Upload and Posting

## Overview

This Node.js module provides functionality to post tweets with media (images, videos, GIFs) to Twitter using Twitter's API. It handles the authentication, media uploading (including chunked uploads for large files), and posting of tweets with the uploaded media.

## Requirements

- Node.js v20.0.0 or higher
- X / Twitter Developer Account with API keys

## Installation

```bash
npm install @kworq/x-api-post
```

## Working with source

1. Clone the repository or copy the code into your project directory.
2. Install the required dependencies using npm:

```bash
npm install
```

## Run source

```bash
node --import ./esm-loader.mjs app.ts
```

## Configuration

Before using this module, you need to set up the configuration with your Twitter API credentials. The configuration object should have the following properties:

- `X_API_KEY`
- `X_API_SECRET`
- `X_API_ACCESS_TOKEN`
- `X_API_ACCESS_TOKEN_SECRET`

## Class

### `XApiClient`

A class to handle posting tweets with media to Twitter.

#### Constructor

Creates an instance of `XApiClient`.

```javascript
new XApiClient(config)
```

##### Parameters:

- `config`: Configuration object containing Twitter API credentials.

#### Methods

##### `postTweetWithMedia(text, mediaUrls)`

Posts a tweet with the specified text and media.

###### Parameters:

- `text`: The text of the tweet.
- `mediaUrls`: An array of media URLs to upload and attach to the tweet.

## Usage Example

```javascript
import XApiClient from '@kworq/x-api-post';

const config = {
  X_API_KEY: 'your_api_key',
  X_API_SECRET: 'your_api_secret',
  X_API_ACCESS_TOKEN: 'your_access_token',
  X_API_ACCESS_TOKEN_SECRET: 'your_access_token_secret',
};

const text = "Hello, world!";
const mediaUrls = ["https://www.w3schools.com/html/mov_bbb.mp4"];

const client = new XApiClient(config);

client.postTweetWithMedia(text, mediaUrls)
  .then((response) => console.log(response))
  .catch((error) => console.error("Error posting tweet:", error));
```

## Notes

- Ensure you have valid Twitter API credentials.
- Media files larger than 5MB will be uploaded in chunks.
- The media upload process includes initialization, appending chunks, finalizing, and checking the status.
- This module requires Node.js v18.0.0 or higher to use the native `fetch` function.

## License

This project is licensed under the MIT License.