open-index/open-npm huggingface dataset:
npm package: @obigtech/ui-theme
Description: System UI spec theme for Obig related projects
Author: Obigtech
Latest version: 2.0.0

# Obig theme

This is the base theme for all Obig related projects, based on the [System UI theme spec](https://system-ui.com/theme).

## Related

- [Obigtech design system](https://blckstack.design)
npm package: @obimadu/outline-mcp
Description: This is an MCP (Model Context Protocol) server for the Outline knowledge base. It exposes Outline's API as MCP tools so clients can read and manage data in Outline.
Latest version: 0.1.4

# Outline MCP Server

This is an MCP (Model Context Protocol) server for the Outline knowledge base.
It exposes Outline's API as MCP tools so clients can read and manage data in Outline.

- Outline website: https://www.getoutline.com/
- Outline GitHub: https://github.com/outline/outline

## What it does

- Provides MCP tools generated from the Outline OpenAPI spec.
- Supports Streamable HTTP (stateless JSON) and stdio transport.
- Uses `Authorization` and `X-Server-Url` headers for HTTP requests.

## Requirements

- Node.js
- An Outline API key

## Run

Build:

```bash
npm run build
```

Start:

```bash
node dist/index.js
```

## CLI flags

- `--stdio` (default when `MCP_PORT` is not set)
- `--http`
- `--port <number>` (HTTP only)
- `-h`, `--help`

Examples:

```bash
npx @obimadu/outline-mcp --stdio
npx @obimadu/outline-mcp --http --port 3000
```

## Configuration

HTTP transport expects:

- `Authorization: Bearer <OUTLINE_API_KEY>`
- `X-Server-Url: https://your-outline-instance`

For stdio, set:

- `OUTLINE_API_KEY`
- `OUTLINE_BASE_URL`
npm package: @obinesto/react-infinite-scroll-carousel
Description: A React infinite scroll carousel component with automatic scrolling and navigation
Author: Cyprian Obi
Latest version: 1.0.6

# React Infinite Scroll Carousel

A React carousel component with infinite scroll functionality and automatic scrolling.

## Installation
 
```bash
npm install @obinesto/react-infinite-scroll-carousel
```

## Usage

```tsx
import '@obinesto/react-infinite-scroll-carousel/dist/index.css';
import { Carousel } from '@obinesto/react-infinite-scroll-carousel';

interface MyItem {
  title: string;
  content: string;
}

const items: MyItem[] = [
  { title: 'Item 1', content: 'Content 1' },
  { title: 'Item 2', content: 'Content 2' },
  // ...more items
];

function MyComponent() {
  return (
    <Carousel
      items={items}
      renderItem={(item) => (
        <div>
          <h3>{item.title}</h3>
          <p>{item.content}</p>
        </div>
      )}
      itemClassName="w-64 p-4 bg-white shadow-md"
      scrollInterval={3000}
      scrollAmount={300}
    />
  );
}
```

## Styling

The component comes with a default stylesheet that you can import. You can override the default styles by passing your own class names to the containerClassName, itemClassName, and navigationButtonClassName props


## Props

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| items | T[] | required | Array of items to display in the carousel |
| keyExtractor | (item: T, index: number) => string \| number | `index` | Function to extract a unique key for each item. |
| renderItem | (item: T, index: number) => ReactNode | required | Function to render each item |
| scrollInterval | number | 3000 | Time in milliseconds between auto-scrolls |
| scrollAmount | number | 300 | Number of pixels to scroll each time |
| itemClassName | string | "" | CSS classes for item containers |
| containerClassName | string | "" | CSS classes for the carousel container |
| navigationButtonClassName | string | "" | CSS classes for navigation buttons |
| loadMoreThreshold | number | 5 | The number of items remaining before loading more to create the infinite scroll effect. |

## License

MIT
npm package: @obinexusltd/obix-binding-go
Description: OBIX Go Binding - Backend microservices, concurrent state management
Author: OBINexus
Latest version: 0.1.1

# @obinexusltd/obix-binding-go

TypeScript bindings for OBIX Go runtime integration through the libpolycall ABI bridge.

## Overview

`@obinexusltd/obix-binding-go` provides a small bridge API for:

- Creating and initializing a Go binding configuration
- Invoking ABI-backed polyglot functions with structured envelopes
- Returning consistent typed invocation errors
- Exposing placeholder runtime and pool statistics interfaces

## Installation

```bash
npm install @obinexusltd/obix-binding-go
```

## Usage

```ts
import { createGoBinding } from '@obinexusltd/obix-binding-go';

const binding = createGoBinding({
  ffiPath: '/path/to/libpolycall.so',
  goPath: '/usr/local/go',
  schemaMode: 'hybrid',
  memoryModel: 'gc',
  cgoEnabled: true,
  goroutinePoolSize: 16,
  concurrencyModel: 'goroutines',
});

await binding.initialize();

const result = await binding.invoke('exampleFunction', ['arg1', 42]);
console.log(result);

await binding.destroy();
```

## API

### `createGoBinding(config: GoBindingConfig): GoBindingBridge`

Creates a binding bridge with lifecycle and invocation methods:

- `initialize()`
- `invoke(fn, args)`
- `destroy()`
- `getMemoryUsage()`
- `getSchemaMode()`
- `isInitialized()`
- `submitTask(taskId, fn, args)`
- `getPoolStats()`

## Error model

Invocation errors are returned as typed objects:

- `NOT_INITIALIZED`
- `MISSING_SYMBOL`
- `INVOCATION_FAILED`

Each includes the invocation envelope metadata for easier debugging at ABI boundaries.

## Development

```bash
npm run build
npm test
```

## License

MIT
npm package: @obinexusltd/obix-binding-swift
Description: OBIX Swift Binding - iOS/macOS native rendering bridge
Author: OBINexus
Latest version: 0.1.1

# @obinexusltd/obix-binding-swift

TypeScript bindings for an OBIX Swift bridge that connects a libpolycall-style FFI layer to Swift runtimes on iOS and macOS.

## Features

- Creates a Swift binding with lifecycle management.
- Builds invocation envelopes for FFI dispatch.
- Exposes dispatch queue, ARC tracking, schema resolution, and Combine stream helpers.
- Supports `monoglot`, `polyglot`, and `hybrid` schema modes.

## Installation

```bash
npm install @obinexusltd/obix-binding-swift
```

## Usage

```ts
import { createSwiftBinding } from '@obinexusltd/obix-binding-swift';

const binding = createSwiftBinding({
  ffiPath: '/path/to/libpolycall',
  schemaMode: 'hybrid',
  memoryModel: 'hybrid',
  objcBridging: true,
  swiftConcurrencyEnabled: true,
  asyncAwaitSupport: true,
  swiftVersion: '5.10',
});

await binding.initialize();

const result = await binding.invoke('render_view', [{ screen: 'home' }]);
console.log(result);

await binding.destroy();
```

## API overview

### `createSwiftBinding(config)`

Creates a `SwiftBindingBridge` with the following core capabilities:

- `initialize()` to validate configuration and mark the bridge ready.
- `invoke(fn, args)` to dispatch FFI calls.
- `submitTask(taskId, fn, args, priority?)` to queue work.
- `getMemoryUsage()` to inspect ARC statistics.
- `getQueueStats()` to inspect dispatch queue activity.
- `getSchemaMode()` and `schemaResolver` helpers for schema behavior.
- `combineStreamManager` for lightweight publisher/subscriber streams.

## Development

```bash
npm test
npm run build
```

## License

MIT.
npm package: @obinexusmk2/nexus-search
Description: A high-performance search indexing and query system using a self-balancing AVL-Trie with BFS/DFS algorithms for fast full-text search, fuzzy matching, real-time updates, and cross-platform file system support.
Author: Nnamdi Michael Okpala
Latest version: 0.5.0

# NexusSearch

A high-performance search indexing and query system with cross-platform file system support.

## Project Structure

```
src/
├── core/              # Core search engine functionality
│   ├── search/        # Search engine implementation
│   ├── documents/     # Document processing
│   ├── storage/       # Storage adapters
│   ├── algorithms/    # Search algorithms
│   └── utils/         # Utility functions
├── adapters/          # Platform-specific adapters
│   ├── browser/       # Browser-specific implementations
│   ├── node/          # Node.js-specific implementations
│   └── common/        # Shared adapter interfaces
├── cli/               # Command-line interface
│   ├── commands/      # CLI command implementations
│   ├── formatters/    # Output formatting
│   └── index.ts       # CLI entry point
├── web/               # Web integration
│   ├── components/    # UI components
│   ├── hooks/         # React hooks
│   └── index.ts       # Web entry point
└── types/             # TypeScript type definitions
```

## File System Compatibility

NexusSearch provides a cross-platform file system abstraction layer that works in both Node.js and browser environments:

- In Node.js: Uses native fs/promises API
- In browsers: Uses File/FileReader API and IndexedDB for storage

## Development

```bash
# Install dependencies
npm install

# Start development with watch mode
npm run dev

# Build for production
npm run build

# Run tests
npm test
```

## Usage

### Node.js

```javascript
import { SearchEngine } from '@obinexusmk2/nexus-search';

const engine = new SearchEngine(config);
await engine.initialize();
const results = await engine.search('query');
```

### Browser

```javascript
import { SearchEngine } from '@obinexusmk2/nexus-search';

const engine = new SearchEngine({
  storage: { type: 'indexeddb' },
  // other config...
});

// File upload example
document.getElementById('fileInput').addEventListener('change', async (e) => {
  const file = e.target.files[0];
  await engine.addDocument({
    id: file.name,
    file: file
  });
});

// Search example
const results = await engine.search('query');
```

### CLI

```bash
# Index documents in a directory
nsc index ./documents

# Search for a term
nsc search "query"

# Export the index
nsc export --output=index.json
```