open-index/open-npm huggingface dataset:
npm package: @sajari/stack
Description: A minimal setup stack queue
Latest version: 1.0.2

# Stack

This stack queue replicates async function like the one used in the Google Analytics (GA) snippet.

Where this comes in handy is putting javascript snippets on html pages without requiring external scripts. The ability to push data and events into a queue before a larger javascript file is loaded is invaluable in certain circumstances.

The code required to set up a stack queue object that is compatible with this library is minimal.

## Browser

Usage like newer Google Analytics, wrapped in a function.

```javascript
// Setup
var arr = [];
sq = sq || function() {
  arr.push(arguments);
};
sq.arr = sq.arr || arr;

// Usage
sq("log", "hello from stack!");
```

## App

From our app we can treat the stack queue object as if it were created by the library.

```javascript
var stackqueue = require("stackqueue");

var log = function(message) {
  console.log(message);
};

// Here we grab the sq declared in our html and initialise it.
stackqueue.flush(window.sq, { log: log });

// Output: "hello from stack!"
```
npm package: @sajeel/google
Description: A lightweight package boasting a simple but groundbreaking set of searching algorithms rivaling that of tech giant, Google
Author: Sajeel
Latest version: 2.2.0

# @sajeel/google

[![npm (scoped)](https://img.shields.io/badge/npm-v2.3.0-blue.svg)](https://www.npmjs.com/package/@sajeel/google)
[![npm bundle size (minified)](https://img.shields.io/badge/build-passing-brightgreen.svg)](https://www.npmjs.com/package/@sajeel/google)
[![dependencies version](https://img.shields.io/badge/dependencies-uptodate-orange.svg)](https://www.npmjs.com/package/@sajeel/google)

A lightweight package boasting a simple but uncontroversially groundbreaking set of searching algorithms rivaling that of tech giant, Google.

## Install

`$ npm install @sajeel/google` 


## Usage:

### Instantiation
```js
    var google = require('@sajeel/google');
```

### Array Search
```js
    var {positions, count, time} = google.search(["captain america", "thor", 
    "black widow", "captain america", "captain america", "iron man", "quicksilver", 
    "spiderman", "starlord", "captain america", "ant man", "dr. strange", "thanos", 
    "captain marvel", "gamora", "hulk", "nebula", "hawkeye", "vision", "scarlet witch"], 
    "captain america");

    console.log(`Captain America appears ${count} time(s) at indices ${positions.length 
    > 1 ? positions.splice(0, positions.length-1).join(", ") + ", and " + 
    positions[positions.length-1]: positions.join("")}. Your search took ${time}s 
    long to execute.`)
    // ==> Captain America appears 4 time(s) at indices 0, 3, 4, and 9. 
    //     Your search took 0.23s long to execute.
```

### Online Search
```js
    google.searchOnline("James Harden Beard");
    // Opens default browser with a Google search.

```
npm package: @sajeel/saitama
Description: A lightweight package demonstrating the unbounded strength of a certain bald hobbyist
Author: Sajeel Malik
Latest version: 1.1.0

# @sajeel/saitama

[![npm (scoped)](https://img.shields.io/badge/npm-v1.1.0-brightgreen.svg)](https://www.npmjs.com/package/@sajeel/saitama)

A lightweight package demonstrating the unbounded strength of a certain bald hobbyist

## Install

```
$ npm install @sajeel/saitama
```

## Usage

```js
const saitama = require("@sajeel/saitama");

saitama("Thanos");
// Saitama took out Thanos in one punch.

saitama(23);
//Uncaught TypeError: Saitama must fight a person. Input a string of the fighter's name.
```
npm package: @sajenid/aksara.js
Description: Transliterator Latin to Javanese Aksara or Javanese Aksara to Latin
Author: Equan Pr.
Latest version: 1.0.0-beta.6

<h2 align="center">
  <p align="center"><i>aksara.js</i></p>
  <!--
  <p align="center"><img src="" width="80%" alt="aksarajs"></p>
  -->
</h2>

Pustaka untuk alih bahasa (*transliterate*) dari Latin ke Aksara Jawa dan sebaliknya dari Aksara Jawa ke Latin.

> Source code dari pustaka ini berdasarkan projek mengagumkan dari [Transliterasi Jawa](https://bennylin.github.com/transliterasijawa)

Tujuan dibuatnya pustaka ini transliterator supaya bisa lebih mudah untuk digunakan oleh pengembang lain dalam membuat aplikasi-aplikasi yang berhubungan dengan alih bahasa Aksara Jawa.

## Instalasi

Instal dari registry npm

```
npm install @sajenid/aksara.js
```

Untuk Github Package Registry

```
npm install @sajenid/aksara.js --registry https://npm.pkg.github.com/
```

## API

Alih bahasa dari Latin ke Aksara Jawa.

```javascript
LatinKeAksara(latin_string)
```

Aliases

```javascript
LatinToAksara(latin_string)
```

```javascript
DoTransliterate(latin_string)
```

## Pemakaian

```javascript
import { LatinKeAksara } from '@sajenid/aksara.js'

let wada = LatinKeAksara('Nulisa Aksara Jawa');

console.log(wada); // ꦤꦸꦭꦶꦱ​ꦄꦏ꧀ꦱꦫ​ꦗꦮ
```

## Contoh

[README.md (Carakan)](https://aksarajs.netlify.app/)

---
MIT © 2020, Sajen.id
npm package: @sajermann/eslint-config
Description: ESLint configuration.
Latest version: 0.0.3

# Sajermann ESLint config

## Setup

1. Install the dependencies
```
npm i -D eslint @sajermann/eslint-config
```

2. Create a `.eslintrc.json` file extending the config:
```
{
  "extends": "@sajermann/eslint-config/react"
}
```

> You can also use a `.eslintrc.js` instead of JSON if you prefer.
npm package: @sajjadgrw1/react-list-lazy-load
Description: Lazy loading wrapper for react-list.
Author: Renée Kooi
Latest version: 1.1.2

# react-list-lazy-load

> **Unmaintained**. Consider using [react-virtual](https://github.com/tanstack/virtual).

Lazy Loading wrapper for [React-List](https://github.com/orgsync/react-list).

This component works for finite collections only. If you have a large list of a
known size that you do not want to load all at once, this component allows
loading pages once the user scrolls near them. It does **not** implement
infinite scrolling.

[![npm][npm-image]][npm-url]
[![travis][travis-image]][travis-url]
[![size][size-image]][size-url]

[npm-image]: https://img.shields.io/npm/v/react-list-lazy-load.svg?style=flat-square
[npm-url]: https://www.npmjs.com/package/react-list-lazy-load
[travis-image]: https://img.shields.io/travis/u-wave/react-list-lazy-load.svg?style=flat-square
[travis-url]: https://travis-ci.org/u-wave/react-list-lazy-load
[size-image]: https://img.shields.io/bundlephobia/minzip/react-list-lazy-load.svg?style=flat-square
[size-url]: https://bundlephobia.com/result?p=react-list-lazy-load

## Installation

```bash
npm install --save react-list-lazy-load
```

## Usage

[Demo](https://u-wave.github.io/react-list-lazy-load) - [Demo source code](./example.js)

You wrap it around a `<ReactList />` element to :sparkles: magically :sparkles:
add lazy loading hooks:

```js
import ReactList from 'react-list';
import LazyLoading from 'react-list-lazy-load';

const MyList = ({ items, onRequestPage }) => (
  <LazyLoading
    length={items.length}
    items={items}
    onRequestPage={onRequestPage}
  >
    <ReactList
      itemRenderer={(idx, key) => (
        <div key={key}>{items[idx]}</div>
      )}
      type="uniform"
      length={items.length}
    />
  </LazyLoading>
);
```

## API

### `items={Array}`

An array of the items you're showing. This is used to determine when to load a
page. If the user scrolls close to a `null` item in this array, or outside of
array bounds, a new page will be loaded.

I.e., a `null` item is regarded as an unloaded item.

### `length={Number}`

The total amount of items, on all "pages". Defaults to

### `pageSize={Number}`

Amount of items on a page. This is used to determine which page to load.
Defaults to 25 (rather arbitrarily).

### `loadMargin={Number}`

When to start loading the next page. The next page will be loaded when the user
scrolls within `loadMargin` items from an unloaded item. You'll want to change
this depending on the size of your items. If your items are super small, you
should pick a larger `loadMargin`, but if they are rather large, you might be
good with a margin of like 1 or 2 items.

Defaults to 5.

### `onRequestPage={function(page, cb)}`

Callback to load a page. This only tells you to load a new page--you should
merge it into the `items` prop yourself.

## Licence

[MIT](./LICENSE)
npm package: @sajko/cli
Description: CLI tool for SAJKO Analytics - Initialize, test, and debug your integration
Author: SAJKO Team
Latest version: 1.0.6

# @sajko/cli

CLI tool for SAJKO Analytics - Initialize, test, and debug your integration.

## Installation

```bash
npm install -g @sajko/cli
# or
npx @sajko/cli
```

## Commands

### Initialize SAJKO

Set up SAJKO in your project with interactive configuration:

```bash
sajko init
```

Options:
- `-f, --framework <framework>` - Specify framework (react, nextjs, vue, vanilla)
- `-p, --package-manager <pm>` - Specify package manager (npm, yarn, pnpm, bun)
- `--no-install` - Skip dependency installation

### Test Integration

Verify your SAJKO setup is working correctly:

```bash
sajko test
```

Options:
- `-w, --website-id <id>` - Website ID to test
- `-e, --endpoint <url>` - API endpoint to test
- `--send-event` - Send a test event

### Debug Mode

Monitor events in real-time with a local debug server:

```bash
sajko debug
```

Options:
- `-w, --website-id <id>` - Website ID to monitor
- `-p, --port <port>` - Local server port (default: 9090)
- `--verbose` - Show detailed event data

Opens a debug console at `http://localhost:9090` where you can:
- View live events from your application
- Send test events
- Monitor event flow
- Debug integration issues

### Doctor

Check your SAJKO setup for common issues:

```bash
sajko doctor
```

Options:
- `--fix` - Attempt to fix issues automatically

The doctor command checks for:
- Configuration file presence and validity
- Correct package installation
- Framework integration
- TypeScript setup
- Common mistakes

## Configuration

SAJKO CLI looks for configuration in these locations:
1. `sajko.config.ts` - TypeScript config
2. `sajko.config.js` - JavaScript config
3. `.sajkorc.json` - JSON config
4. `package.json` - Under `sajko` field

Example configuration:

```javascript
// sajko.config.js
module.exports = {
  websiteId: 'your-website-id',
  apiEndpoint: 'https://api.sajko.sk',
  debug: process.env.NODE_ENV === 'development'
};
```

## Examples

### Quick Start

```bash
# Initialize in a React project
npx @sajko/cli init --framework react

# Test the integration
npx @sajko/cli test --send-event

# Start debugging
npx @sajko/cli debug --verbose
```

### CI/CD Integration

```bash
# In your CI pipeline
npx @sajko/cli test --website-id $SAJKO_WEBSITE_ID
```

### Development Workflow

```bash
# Start debug server in one terminal
sajko debug --verbose

# Run your app in another terminal
npm run dev

# Monitor events in real-time at http://localhost:9090
```

## Troubleshooting

If you encounter issues:

1. Run the doctor command:
   ```bash
   sajko doctor --fix
   ```

2. Check debug output:
   ```bash
   sajko debug --verbose
   ```

3. Verify configuration:
   ```bash
   sajko test
   ```

## License

MIT
npm package: @sajko/nextjs
Description: Next.js integration for SAJKO analytics
Author: SAJKO Team
Latest version: 1.0.5

# @sajko/nextjs

Next.js integration for SAJKO Analytics with App Router and Pages Router support.

## Installation

```bash
npm install @sajko/nextjs @sajko/tracker @sajko/react
```

## Usage

### App Router

```jsx
// app/layout.tsx
import { SajkoScript } from '@sajko/nextjs';

export default function RootLayout({ children }) {
  return (
    <html>
      <body>
        {children}
        <SajkoScript config={{ websiteId: 'your-website-id' }} />
      </body>
    </html>
  );
}
```

### Pages Router

```jsx
// pages/_app.tsx
import { SajkoScript } from '@sajko/nextjs';

export default function App({ Component, pageProps }) {
  return (
    <>
      <Component {...pageProps} />
      <SajkoScript config={{ websiteId: 'your-website-id' }} />
    </>
  );
}
```

### Using Hooks

```jsx
import { useTracker, usePageView } from '@sajko/nextjs';

export default function Page() {
  const track = useTracker();
  usePageView(); // Auto-track page views
  
  return <button onClick={() => track('click')}>Track Event</button>;
}
```

## Documentation

For full documentation, visit [https://github.com/sajkoapp/sajko-tracker](https://github.com/sajkoapp/sajko-tracker)

## License

MIT
npm package: @sajko/react
Description: React hooks and components for SAJKO analytics
Author: SAJKO Team
Latest version: 1.0.5

# @sajko/react

React hooks and components for SAJKO Analytics integration.

## Installation

```bash
npm install @sajko/react @sajko/tracker
```

## Usage

```jsx
import { SajkoProvider, useSajko, usePageView } from '@sajko/react';

// Wrap your app with the provider
function App() {
  return (
    <SajkoProvider config={{ websiteId: 'your-website-id' }}>
      <YourApp />
    </SajkoProvider>
  );
}

// Use hooks in your components
function MyComponent() {
  const { track, identify } = useSajko();
  
  // Auto-track page views
  usePageView();
  
  const handleClick = () => {
    track('button_click', { button: 'cta' });
  };
  
  return <button onClick={handleClick}>Click Me</button>;
}
```

## Documentation

For full documentation, visit [https://github.com/sajkoapp/sajko-tracker](https://github.com/sajkoapp/sajko-tracker)

## License

MIT
npm package: @sajko/tracker
Description: Core tracking library for SAJKO analytics and session replay
Author: SAJKO Team
Latest version: 1.0.3

# @sajko/tracker

Core tracking library for SAJKO Analytics - Advanced session replay and analytics for modern web apps.

## Installation

```bash
npm install @sajko/tracker
```

## Usage

```javascript
import { createTracker } from '@sajko/tracker';

const tracker = createTracker({
  websiteId: 'your-website-id',
  apiEndpoint: 'https://api.sajko.sk'
});

// Track events
tracker.track('page_view', {
  page: window.location.pathname
});

// Identify users
tracker.identify('user-123', {
  email: 'user@example.com',
  plan: 'premium'
});
```

## Documentation

For full documentation, visit [https://github.com/sajkoapp/sajko-tracker](https://github.com/sajkoapp/sajko-tracker)

## License

MIT
npm package: @sajko/vue
Description: Vue.js plugin for SAJKO analytics
Author: SAJKO Team
Latest version: 1.0.3

# @sajko/vue

Vue 3 integration for SAJKO Analytics with Composition API support.

## Installation

```bash
npm install @sajko/vue @sajko/tracker
```

## Usage

### Plugin Setup

```javascript
// main.js
import { createApp } from 'vue';
import { SajkoPlugin } from '@sajko/vue';
import App from './App.vue';

const app = createApp(App);

app.use(SajkoPlugin, {
  websiteId: 'your-website-id',
  apiEndpoint: 'https://api.sajko.sk' // optional
});

app.mount('#app');
```

### Composition API

```vue
<template>
  <button @click="trackClick">Track Event</button>
</template>

<script setup>
import { useSajko, usePageView } from '@sajko/vue';

const { track, identify, getSessionId } = useSajko();

// Auto-track page views
usePageView();

const trackClick = () => {
  track('button_click', { 
    button: 'cta',
    page: 'home' 
  });
};
</script>
```

## Documentation

For full documentation, visit [https://github.com/sajkoapp/sajko-tracker](https://github.com/sajkoapp/sajko-tracker)

## License

MIT
npm package: @sajn/embed-js
Description: Embed sajn e-signature functionality in any web application
Author: sajn
Latest version: 0.1.5

# @sajn/embed

Embed sajn's e-signature functionality directly into your applications using vanilla JavaScript.

## Installation

```bash
npm install @sajn/embed
```

Or via CDN:

```html
<script src="https://unpkg.com/@sajn/embed"></script>
```

## Quick Start

```html
<div id="signing"></div>
<script>
  sajn.embedSignDocument({
    element: '#signing',
    documentId: 'your-document-id',
    token: 'your-token',
    onSignerCompleted: (data) => console.log('Signed!', data),
    onSignerRejected: (data) => console.log('Rejected', data),
  });
</script>
```

Or as a Web Component:

```html
<sajn-sign-document
  document-id="your-document-id"
  token="your-token"
></sajn-sign-document>

<script>
  document.querySelector('sajn-sign-document')
    .addEventListener('signer-completed', (e) => console.log(e.detail));
</script>
```

## Documentation

For full documentation, events, and configuration options, see the [main README](https://github.com/sajn-se/embeds#readme).
npm package: @sajn/embed-react
Description: React component for embedding sajn e-signature functionality
Author: sajn
Latest version: 0.1.5

# @sajn/embed-react

React component for embedding sajn's e-signature functionality directly into your applications.

## Installation

```bash
npm install @sajn/embed-react
```

## Quick Start

```tsx
import { EmbedSignDocument } from '@sajn/embed-react';

function App() {
  return (
    <EmbedSignDocument
      documentId="your-document-id"
      token="your-token"
      onSignerCompleted={(data) => console.log('Signed!', data)}
      onSignerRejected={(data) => console.log('Rejected', data)}
    />
  );
}
```

## Documentation

For full documentation, events, and configuration options, see the [main README](https://github.com/sajn-se/embeds#readme).
npm package: @sajn/embed-vue
Description: Vue component for embedding sajn e-signature functionality
Author: sajn
Latest version: 0.1.5

# @sajn/embed-vue

Vue component for embedding sajn's e-signature functionality directly into your applications.

## Installation

```bash
npm install @sajn/embed-vue
```

## Quick Start

```vue
<script setup>
import { EmbedSignDocument } from '@sajn/embed-vue';

function handleComplete(data) {
  console.log('Signed!', data);
}
</script>

<template>
  <EmbedSignDocument
    document-id="your-document-id"
    token="your-token"
    @signer-completed="handleComplete"
    @signer-rejected="(data) => console.log('Rejected', data)"
  />
</template>
```

## Documentation

For full documentation, events, and configuration options, see the [main README](https://github.com/sajn-se/embeds#readme).
npm package: @sajou/mcp-server
Description: MCP server for sajou — lets AI agents interact with the visual choreographer via Model Context Protocol
Latest version: 0.7.1

# @sajou/mcp-server

MCP (Model Context Protocol) server for sajou. Lets AI agents interact with the visual choreographer via the standard MCP protocol.

## Setup

### 1. Start the scene-builder dev server

```bash
pnpm --filter scene-builder dev
```

The scene-builder runs on `http://localhost:5175` by default.

### 2. Configure your MCP client

#### Claude Code

Add to your MCP config (`~/.claude/claude_desktop_config.json` or project `.mcp.json`):

```json
{
  "mcpServers": {
    "sajou": {
      "command": "npx",
      "args": ["-y", "@sajou/mcp-server"],
      "env": {
        "SAJOU_DEV_SERVER": "http://localhost:5175"
      }
    }
  }
}
```

#### Development (from this repo)

```json
{
  "mcpServers": {
    "sajou": {
      "command": "npx",
      "args": ["tsx", "packages/mcp-server/src/index.ts"],
      "env": {
        "SAJOU_DEV_SERVER": "http://localhost:5175"
      }
    }
  }
}
```

## Tools

| Tool | Description |
|------|-------------|
| `emit_signal` | Emit a signal to the scene. Triggers choreographies. |
| `get_scene_state` | Get current scene entities (id, position, visibility). |
| `get_choreographies` | List available choreographies with descriptions. |
| `list_themes` | List available themes (citadel, office). |
| `get_catalog` | Get entity catalog for a theme (buildings, units, etc.). |
| `map_signals` | Map a signal type to a choreography. |

## Environment variables

| Variable | Default | Description |
|----------|---------|-------------|
| `SAJOU_DEV_SERVER` | `http://localhost:5175` | URL of the scene-builder dev server |

## Architecture

```
AI Agent (Claude) ──MCP/stdio──> sajou-mcp ──HTTP──> scene-builder dev server
                                                      │
                                                      ├── POST /api/signal (emit signals)
                                                      ├── GET /api/scene/state (scene state)
                                                      └── GET /__signals__/stream (SSE)
```

The MCP server is a thin adapter. It translates MCP tool calls into HTTP requests against the scene-builder's existing API endpoints. The scene-builder handles all signal routing, choreography execution, and rendering.