open-index/open-npm huggingface dataset:
npm package: @neo-cicada/meme-coin-tracker
Description: meme coin tracker
Author: Lord Neo Barnachea
Latest version: 1.1.2

## Meme Coin Fetcher

### Description

Meme Coin Fetcher is a Node.js package that allows you to retrieve information about meme coins from CoinMarketCap's API.

### Installation

```bash
npm i @neo-cicada/meme-coin-tracker
```

### Usage

```javascript
const { fetchMemeCoinInfo } = require('meme-coin-fetcher');

async function getMemeCoins() {
    try {
        const memeCoins = await fetchMemeCoinInfo();
        console.log(memeCoins);
    } catch (error) {
        console.error('Error fetching meme coin information:', error);
    }
}

getMemeCoins();
```

### API

#### fetchMemeCoinInfo()

This function retrieves information about meme coins from CoinMarketCap's API.

- Returns: An array of meme coins with their information.

### Endpoints

#### Express Endpoints

If you're building a server-side application, you can use the provided Express endpoints to fetch meme coin information.

- `GET /api/meme-coins`: Retrieves information about all meme coins.
- `GET /api/meme-coins/:id`: Retrieves information about a specific meme coin by ID.

Example usage:

```bash
curl http://localhost:3001/api/meme-coins
```

### Dependencies

- axios
- dotenv
- express

### License

This package is licensed under the MIT License.
npm package: @neo-office/core-types
Description: TypeScript type definitions and model mappers for Office Open XML documents (DOCX, PPTX).
Latest version: 0.1.1

# @neo-office/core-types

TypeScript type definitions, document models, and mappers for Office Open XML documents (DOCX, PPTX, XLSX).

## Installation

```bash
npm install @neo-office/core-types
```

## What's Inside

- **Document models** — `ParsedDocument`, `PptxPresentation`, `DocxDocument`, `XlsxWorkbook` and all their child types
- **Engine interfaces** — `PreviewEngine`, `DocumentHandle`, `RenderResult`, `SearchResult`
- **Renderer types** — `RenderMode`, `ViewMode`, `PageInfo`
- **Mutation types** — `DocumentMutation` for edit operations
- **`EditSession`** — tracks in-progress edits before they are committed
- **`mapParsedDocument` / `mapShape`** — map raw WASM JSON output into typed models

## Usage

```ts
import type { ParsedDocument, PptxPresentation, DocxDocument } from '@neo-office/core-types';
import { mapParsedDocument } from '@neo-office/core-types';

// Map raw JSON from the WASM engine into a typed document
const doc: ParsedDocument = mapParsedDocument(rawJson);

if (doc.format === 'pptx') {
  const pptx: PptxPresentation = doc.presentation;
  console.log(pptx.slides.length, 'slides');
}
```

## Packages that depend on this

| Package | Role |
|---|---|
| `@neo-office/renderer` | WASM engine client |
| `@neo-office/ui-shell` | React viewer components |
| `@neo-office/web-sdk` | High-level browser SDK |

## License

MIT
npm package: @neo-office/renderer
Description: WASM-based Office document renderer for the browser. Parses and renders DOCX/PPTX entirely client-side via WebAssembly.
Latest version: 0.1.1

# @neo-office/renderer

WASM-based Office document renderer for the browser. Parses and renders DOCX, PPTX, and XLSX entirely client-side via WebAssembly — no server required.

## Installation

```bash
npm install @neo-office/renderer
```

## How It Works

The Rust engine (`neo-office-wasm`) is compiled to WASM and runs inside a **Web Worker** so the main thread is never blocked. `WorkerClient` is the async TypeScript interface to that worker.

## Usage

```ts
import { WorkerClient } from '@neo-office/renderer';

// Point at the bundled worker file
const workerUrl = new URL('@neo-office/renderer/worker', import.meta.url);
const worker = new Worker(workerUrl, { type: 'module' });
const client = new WorkerClient(worker);

// 1. Initialise the WASM engine
await client.init();

// 2. Load a file
const bytes = new Uint8Array(await file.arrayBuffer());
const docId = await client.loadDocument(bytes);

// 3. Inspect the document
const summary  = await client.openPackage(docId);   // format, part counts
const metadata = await client.getMetadata(docId);    // author, title, …
const parsed   = await client.parseDocument(docId);  // full typed model JSON

// 4. Get page dimensions
const pages = await client.allPageInfo(docId);
// [{ width: 9144000, height: 5143500 }, …]  (EMU units for PPTX)

// 5. Render a page to an ImageData bitmap
const imageData = await client.renderPage(docId, 0, 1280, 720, 0);
// → ImageData — draw directly onto a <canvas>

// 6. Clean up
client.dispose();
```

## API

### `WorkerClient`

| Method | Returns | Description |
|---|---|---|
| `init()` | `Promise<void>` | Load and initialise the WASM engine |
| `loadDocument(bytes)` | `Promise<string>` | Store raw bytes; returns a document ID |
| `openPackage(id)` | `Promise<object>` | Format detection and OPC summary |
| `getMetadata(id)` | `Promise<object>` | Title, author, creation date, … |
| `parseDocument(id)` | `Promise<object>` | Full OOXML model as JSON |
| `allPageInfo(id)` | `Promise<PageInfo[]>` | Page/slide dimensions |
| `layoutDocument(id)` | `Promise<object>` | DOCX page-break layout |
| `renderPage(id, pageIndex, w, h, priority)` | `Promise<ImageData>` | Rasterise one page via WASM |
| `cancelRender(reqId)` | `void` | Cancel a pending render |
| `dispose()` | `void` | Terminate the worker |

### `PageInfo`

```ts
interface PageInfo {
  width: number;   // EMU for PPTX, points for DOCX
  height: number;
  name?: string;   // slide name if present
}
```

## Bundler Notes

The worker script at `@neo-office/renderer/worker` must be served as a separate chunk. With **Vite**:

```ts
new URL('@neo-office/renderer/worker', import.meta.url)
// Vite automatically code-splits this into its own chunk
```

With **webpack** use `/* webpackChunkName */` or a dynamic import.

## License

MIT