open-index/open-npm huggingface dataset:
npm package: @line100/plug-layout
Description: ## Usage
Latest version: 0.1.1

# plug-layout

## Usage

```ts
type TData = {
	name: string,
	version: number,
	instruction: 1,
	phone: {
		type: number,
		number: Buffer,
	},
	address: {
		type: number,
		number: Buffer,
	}
}

let layout = createLayout<TData>([
	StringPlug('name'),
	U8Plug('version'),
	ConstU8Plug('instruction', 1),
	StructPlug('phone', [
		U8Plug('type'),
		BufferPlug('number'),
	]),
	StructPlug('address', [
		U8Plug('type'),
		BufferPlug('number'),
	]),
])
```
npm package: @line100/rescript-nom
Description: The only official ReScript starter template.
Latest version: 0.0.1

# ReScript Project Template

The only official ReScript starter template.

## Installation

```sh
npm install
```

## Build

- Build: `npm run build`
- Clean: `npm run clean`
- Build & watch: `npm run start`

## Run

```sh
node src/Demo.bs.js
```
npm package: @line100/rescript-seq
Description: A `Lazy Sequence` implimation. Highly abstracted stream like `RxJs` but without `time`.
Latest version: 0.1.0

# rescript-seq

A `Lazy Sequence` implimation. Highly abstracted stream like `RxJs` but without `time`.

```txt

  Deleted Head                        Infinit Tail

┌───┐   ┌───┐   ┌──┬┐   ┌──┬┐   ┌──┬┐
│   │   │   │   │ a│┼───► b│┼───► c│┼───►  ?
└───┘   └───┘   └──┴┘   └──┴┘   └──┴┘
                  ▲       ▲
                  │       │
                  │       │
          ┌─────┬─┘    ┌──┴──┐
          │ ref │      │ ref │
          └─────┘      └─────┘

```

## Installation

```sh
npm install @line100/rescript-seq
```

## Usage

```rescript
// infinit sequence of numbers
let rec createInfinitSeq = (i) =>
    Seq.cons(i, Seq.Lazy(() => Some(createInfinitSeq(i + 1))))

// take and lazyTake
let seq = createInfinitSeq(0)
let first3 = Seq.take(seq, 3)
seqEqual(~message="take first 3 from infinit list", first3, list{0, 1, 2})

let first3 = Seq.lazyTake(seq, 3)
seqEqual(~message="lazyTake first 3 from infinit list", first3, list{0, 1, 2})


// map and lazyMap
let first3 = seq->Seq.take(3)->Seq.map(v => v + 1)
seqEqual(~message="map v + 1 after take first 3 from infinit list", first3, list{1, 2, 3})

let first3 = seq->Seq.lazyMap(v => v + 1)->Seq.take(3)
seqEqual(~message="lazyMap v + 1 before take first 3 from infinit list", first3, list{1, 2, 3})
```

## API

### Creation Operators
- [x] fromList: `(list<'a>) => t<'a>`
- [x] fromArray: `(Array<'a>) => t<'a>`
- [x] fromArrayInPlace: `(Array<'a>) => t<'a>`
- [x] fromString: `(string) => t<string>`, convert `string` to `sequence of char`

### Conditional Operator
- [x] isEmpty: `(t<'a>) => bool`
- [x] equal: `(t<'a>, t<'a>) => bool`
- [x] match: `(t<'a>, list<'a>) => bool`
- [x] every: `(t<'a>, 'a => bool) = bool`

### Transformation Operator
- [x] map: `(t<'a>, 'a => 'b) => t<'b>`
- [x] append: `(t<'a>, t<'a>) => t<'a>`

- [x] lazyMap: `(t<'a>, 'a => 'b) => t<'b>`

### filtering operators
- [x] take: `(t<'a>, int) => t<'a>`
- [x] takeWhile: `(t<'a>, 'a => bool) => t<'a>`
- [x] drop: `(t<'a>, int) => t<'a>`
- [x] dropWhile: `(t<'a>, 'a => bool) => t<'a>`

- [x] lazyTake: `(t<'a>, int) => t<'a>`
- [x] lazyTakeWhile: `(t<'a>, 'a => bool) => t<'a>`
npm package: @line45/elevation-profiler
Description: Javascript utility for generating an elevataion profile from a GeoJSON LineString.
Author: Line 45
Latest version: 1.0.5

# Elevation-Profiler
Elevation-profiler is a Javascript utility for generating an elevation profile from a GeoJSON LineString.

Elevation-profiler relies on Mapbox Terrain-RGB tiles, so a Mapbox API access token is required.

## Installation

With npm:

    npm install @line45/elevation-profiler

## Usage

    import getLineStringElevationPoints from "@line45/elevation-profiler";

    getLineStringElevationPoints(linestring, numberOfPoints, mapboxAccessToken).then(function(featureCollection) {
        // Your featureCollection processing code
    }

### Parameters
    
{Object} lineString: The GeoJSON LineString feature to be checked.

{number} numberOfPoints: The maximum number of points to check along the LineString.

{string} mapboxAccessToken: The mapbox access token to be used to retrieve rgb elevation tiles.

{number} minMetersBetweenPoints (Optional): The minimum distance in meters to use between each point on the LineString. 
                                            By default, the approximate pixel distance at the used zoom level and 
                                            is calculated and used as the minimum distance. Passing null results in 
                                            no minimum being applied, so numberOfPoints points are checked regardless 
                                            of LineString length.

### Return value

The returned GeoJSON FeatureCollection contains all checked points along the provided LineString, with an
"elevation" property attribute containing the point's elevation.
npm package: @lineai/agent-pay
Description: A payment card for ai agents that mortals can use too
Latest version: 0.0.2

# @lineai/agent-pay

A reusable React component library for creating beautiful payment cards with Stripe integration. Built for AI agents and humans alike.

## Features

- 🎨 Beautiful, customizable payment card UI
- 🌓 Light and dark theme support
- 💳 Built on official Stripe React components
- 🔒 Secure payment processing with Stripe Elements
- 📱 Responsive design
- 🎯 Full TypeScript support
- ⚡ Easy to integrate
- 🤖 AI agent-friendly design

## Installation

```bash
yarn add @lineai/agent-pay
# or
npm install @lineai/agent-pay
```

## Quick Start

```tsx
import { PaymentCard } from '@lineai/agent-pay';
import type { Product, PaymentConfig } from '@lineai/agent-pay';

const product: Product = {
  id: 'prod_123',
  name: 'Pro Plan',
  description: 'Best for growing businesses',
  price: 2999, // $29.99 in cents
  currency: 'usd',
  features: ['Feature 1', 'Feature 2'],
  recurring: { interval: 'month' }
};

const config: PaymentConfig = {
  publishableKey: 'pk_test_...',
  apiEndpoint: '/api/create-payment-intent',
  theme: 'light'
};

<PaymentCard
  product={product}
  config={config}
  onSuccess={(paymentIntent) => console.log('Success!')}
  onError={(error) => console.error('Error:', error)}
/>
```

## Server Setup

You need a server endpoint to create payment intents:

```javascript
app.post('/api/create-payment-intent', async (req, res) => {
  const { amount, currency, productId } = req.body;
  
  const paymentIntent = await stripe.paymentIntents.create({
    amount,
    currency,
    metadata: { productId }
  });
  
  res.json({ clientSecret: paymentIntent.client_secret });
});
```

## API Reference

### PaymentCard Props

| Prop | Type | Required | Description |
|------|------|----------|-------------|
| product | `Product` | Yes | Product details to display |
| config | `PaymentConfig` | Yes | Stripe configuration |
| onSuccess | `(paymentIntent) => void` | No | Success callback |
| onError | `(error) => void` | No | Error callback |
| className | `string` | No | Additional CSS classes |

### Product Interface

```typescript
interface Product {
  readonly id: string;
  readonly name: string;
  readonly description: string;
  readonly price: number; // in cents
  readonly currency: string;
  readonly features?: readonly string[];
  readonly badge?: string;
  readonly recurring?: {
    readonly interval: 'month' | 'year';
    readonly intervalCount?: number;
  };
}
```

### PaymentConfig Interface

```typescript
interface PaymentConfig {
  readonly publishableKey: string;
  readonly apiEndpoint?: string;
  readonly theme?: 'light' | 'dark';
  readonly tokenAuth?: string;
}
```

## Functional Programming Design

This library is built with functional programming principles:
- Pure functions with no side effects
- Immutable data structures
- No classes - only functions and constants
- Minimal abstractions
- Composable utilities

## Development

```bash
# Install dependencies
yarn install

# Build the library
yarn build

# Run tests
yarn test

# Fix linting issues
yarn fix
```

## License

MIT © Line AI
npm package: @lineai/cognee-api
Description: A simple library for the Cognee API
Latest version: 1.0.19

# @lineai/memory

A functional TypeScript client library for the Cognee API. This library provides a simple, type-safe interface for interacting with Cognee's knowledge graph and memory management services.

## Installation

```bash
npm install @lineai/cognee-api
# or
yarn add @lineai/cognee-api
```

## Quick Start

```typescript
import { CogneeConfig, login, addData, cognify, search, SearchType } from '@lineai/cognee-api';

// Configure the client
const config: CogneeConfig = {
  baseUrl: 'http://localhost:8000',
};

// Login (if authentication is required)
await login(config, {
  username: 'your-username',
  password: 'your-password',
});

// Add data to a dataset
const file = new File(['content'], 'document.txt');
await addData(config, [file], {
  datasetName: 'my-dataset',
});

// Process the data into a knowledge graph
await cognify(config, {
  datasets: ['my-dataset'],
});

// Search the knowledge graph
const results = await search(config, {
  query: 'What is in the document?',
  dataset_name: 'my-dataset',
  search_type: SearchType.GRAPH_COMPLETION,
});

console.log(results);
```

## Core Concepts

### Configuration

All API functions require a `CogneeConfig` object:

```typescript
interface CogneeConfig {
  baseUrl: string;  // The Cognee API base URL
  apiKey?: string;  // Optional API key for cloud services
}
```

### Functional API

All functions follow a simple pattern:
```typescript
(config: CogneeConfig, ...params) => Promise<Result>
```

This makes them easy to compose, test, and use with different configurations.

## API Reference

See the full documentation below for all available functions and types.

## Philosophy

This library follows functional programming principles:

- **Pure functions**: All API calls are pure functions of their inputs
- **Immutability**: All data structures use `readonly` properties
- **Composition**: Functions are designed to be easily composed
- **Minimal abstraction**: Direct mapping to API endpoints
- **Type safety**: Full TypeScript support

## License

MIT
npm package: @lineai/service-data-admin
Description: Server-side service data library for Firebase Admin operations
Latest version: 1.0.3

# @lineai/service-data-admin

Server-side Firebase Admin SDK library for LineAI service data operations.

## Installation

```bash
npm install @lineai/service-data-admin @lineai/service-data-types firebase-admin
```

## Setup

Set your Firebase service account credentials using environment variable (recommended):

```bash
export GOOGLE_APPLICATION_CREDENTIALS=./service-accounts/admin-85663/firebase-adminsdk.json
```

## Usage

```typescript
import { ServiceDataAdmin, initializeAdminApp } from '@lineai/service-data-admin';

// Initialize Firebase Admin (automatically uses GOOGLE_APPLICATION_CREDENTIALS)
const app = initializeAdminApp();

// Or explicitly specify service account path
// const app = initializeAdminApp('/path/to/firebase-service-account.json');

// Create admin client for LineAI business domain
const admin = new ServiceDataAdmin({
  organization: 'customer-org-id',    // LineAI customer organization
  project: 'customer-project-id',     // Customer's project
  service: 'lineai-ai-service'        // LineAI service (e.g., 'ai-models', 'analytics')
}, app);

// Use the admin client
const doc = await admin.get('users', 'user-123');
await admin.set('users', 'user-123', { name: 'John Doe' });

// Convert data for client consumption
import { toJSON } from '@lineai/service-data-admin';
const clientSafeData = toJSON(firestoreData);
```

### Credential Priority

1. **Explicit path**: `initializeAdminApp('/path/to/service-account.json')`
2. **Environment variable**: `GOOGLE_APPLICATION_CREDENTIALS` (recommended)

## Features

- Full CRUD operations with server timestamps
- Batch operations
- Service-level document management
- Query and filtering support
- Data serialization utilities
- Built-in service account management
- TypeScript support

## License

MIT
npm package: @lineai/service-data-client
Description: Client-side service data library for Firebase operations (browser-compatible)
Latest version: 1.0.3

# @lineai/service-data-client

Browser-compatible Firebase client library for LineAI service data operations.

## Installation

```bash
npm install @lineai/service-data-client @lineai/service-data-types firebase
```

## Usage

```typescript
import { initializeApp } from 'firebase/app';
import { getFirestore } from 'firebase/firestore';
import { ServiceDataClient } from '@lineai/service-data-client';

// Initialize Firebase with your project credentials
const app = initializeApp({
  projectId: 'your-firebase-project-id',
  // ... other Firebase config
});

const db = getFirestore(app);

// Create client for LineAI business domain
const client = new ServiceDataClient({
  organization: 'customer-org-id',    // LineAI customer organization
  project: 'customer-project-id',     // Customer's project
  service: 'lineai-ai-service'        // LineAI service (e.g., 'ai-models', 'analytics')
}, db);

// Use the client
const doc = await client.get('users', 'user-123');
await client.set('users', 'user-123', { name: 'John Doe' });
```

## Features

- Full CRUD operations
- Batch operations
- Service-level document management
- Query and filtering support
- TypeScript support

## License

MIT