open-index/open-npm huggingface dataset:
npm package: @nebula-ai/openclaw-nebula
Description: OpenClaw Nebula memory plugin
Latest version: 1.1.0

# OpenClaw Nebula Memory Plugin

Long-term semantic memory for OpenClaw powered by Nebula AI. Automatically captures conversations and provides agent-driven search to recall relevant context from past interactions.

## Installation

```bash
openclaw plugins install @nebula-ai/openclaw-nebula
```

Restart OpenClaw after installation.

## Configuration

### Quick Setup (Copy & Paste)

1. Get your API key and collection ID at [trynebula.ai](https://trynebula.ai)
2. Run this command (replace with your actual values):

```bash
echo -e "NEBULA_API_KEY=neb_xxx\nNEBULA_COLLECTION_ID=your_collection_id" >> ~/.openclaw/.env && openclaw gateway restart
```

Done! The plugin will automatically read your credentials from the .env file.

### Alternative: Config File

Edit `~/.openclaw/openclaw.json`:

```json
{
  "plugins": {
    "entries": {
      "openclaw-nebula": {
        "enabled": true,
        "config": {
          "apiKey": "your_api_key_here",
          "collectionId": "your_collection_id_here"
        }
      }
    }
  }
}
```

Then restart: `openclaw gateway restart`

### Optional Settings

| Option | Default | Description |
|--------|---------|-------------|
| `collectionName` | — | Optional display name for the collection |
| `autoCapture` | `true` | Auto-store conversations after AI turns |
| `debug` | `false` | Enable debug logging |

## Usage

### Automatic Capture

Once configured, the plugin automatically stores conversation turns as memories after each AI response.

### Agent Tool

The AI agent can search stored memories during conversations:

#### `nebula_search`
Search stored memories for relevant context. The agent is encouraged to proactively use this tool to recall user preferences, past discussions, and relevant information before responding.

```typescript
nebula_search({ query: "coding preferences" })
```

### Slash Commands

#### `/nebula-remember <text>`
Manually save to memory.
```
/nebula-remember I prefer TypeScript for new projects
```

#### `/nebula-recall <query>`
Search and display memories.
```
/nebula-recall typescript preferences
```

### CLI Commands

#### Search memories
```bash
openclaw nebula search "python coding style"
```

**Warning:** Wipe permanently deletes all memories and cannot be undone.

## Troubleshooting

### Plugin won't load
**Error:** `nebula: apiKey is required`
Set the `NEBULA_API_KEY` environment variable or add it to your config file.

**Error:** `nebula: collectionId is required`
Set the `NEBULA_COLLECTION_ID` environment variable or add it to your config file. Get your collection ID from [trynebula.ai](https://trynebula.ai).

### No search results
Nebula takes 5-10 seconds to index new memories. Wait after storing before searching.

### Enable debug mode
Add to config:
```json
{
  "config": {
    "debug": true
  }
}
```

Check OpenClaw logs for `[nebula]` messages.

## Support

- Documentation: [docs.openclaw.ai](https://docs.openclaw.ai)
- Nebula AI: [trynebula.ai](https://trynebula.ai)

## License

MIT
npm package: @nebula-db/cli
Description: CLI tools for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/cli

CLI tools for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/cli
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/cli';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/core
Description: Core package for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/core

Core package for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/core
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/devtools
Description: DevTools for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/devtools

DevTools for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/devtools
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/devtools';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/json-schema
Description: JSON Schema utilities for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/json-schema

JSON Schema utilities for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/json-schema
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/json-schema';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/orm
Description: ORM-style modeling for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/orm

ORM-style modeling for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/orm
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/orm';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/plugin-cache
Description: Query caching plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/plugin-cache

Query caching plugin for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-cache
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createCachePlugin } from '@nebula-db/plugin-cache';

// Create the plugin
const cachePlugin = createCachePlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [cachePlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/plugin-encryption
Description: Encryption plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/plugin-encryption

Encryption plugin for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-encryption
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createEncryptionPlugin } from '@nebula-db/plugin-encryption';

// Create the plugin
const encryptionPlugin = createEncryptionPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [encryptionPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/plugin-logger
Description: Logging plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/plugin-logger

Logging plugin for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-logger
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createLoggerPlugin } from '@nebula-db/plugin-logger';

// Create the plugin
const loggerPlugin = createLoggerPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [loggerPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/plugin-migration
Description: Schema migration plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.3

# @nebula-db/plugin-migration

Schema migration plugin for NebulaDB

Part of the [NebulaDB](https://github.com/Nom-nom-hub/NebulaDB) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-migration
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createMigrationPlugin } from '@nebula-db/plugin-migration';

// Create the plugin
const migrationPlugin = createMigrationPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [migrationPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://github.com/Nom-nom-hub/NebulaDB).

## License

MIT
npm package: @nebula-db/plugin-sync
Description: Synchronization plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.5

# @nebula-db/plugin-sync

Synchronization plugin for NebulaDB

Part of the [NebulaDB](https://bitbucket.org/blaze-install/nebula-db) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-sync
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createSyncPlugin } from '@nebula-db/plugin-sync';

// Create the plugin
const syncPlugin = createSyncPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [syncPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://bitbucket.org/blaze-install/nebula-db).

## License

MIT
npm package: @nebula-db/plugin-validation
Description: Schema validation plugin for NebulaDB using Zod
Author: Nom-nom-hub
Latest version: 0.2.3

# @nebula-db/plugin-validation

Schema validation plugin for NebulaDB using Zod

Part of the [NebulaDB](https://github.com/Nom-nom-hub/NebulaDB) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-validation
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createValidationPlugin } from '@nebula-db/plugin-validation';

// Create the plugin
const validationPlugin = createValidationPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [validationPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://github.com/Nom-nom-hub/NebulaDB).

## License

MIT
npm package: @nebula-db/plugin-versioning
Description: Document versioning plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.3

# @nebula-db/plugin-versioning

Document versioning plugin for NebulaDB

Part of the [NebulaDB](https://github.com/Nom-nom-hub/NebulaDB) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/plugin-versioning
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createVersioningPlugin } from '@nebula-db/plugin-versioning';

// Create the plugin
const versioningPlugin = createVersioningPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [versioningPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://github.com/Nom-nom-hub/NebulaDB).

## License

MIT
npm package: @nebula-db/vite-plugin
Description: Vite plugin for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.3

# @nebula-db/vite-plugin

Vite plugin for NebulaDB

Part of the [NebulaDB](https://github.com/Nom-nom-hub/NebulaDB) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/vite-plugin
```

## Usage

```typescript
import { createDb } from '@nebula-db/core';
import { MemoryAdapter } from '@nebula-db/adapter-memory';
import { createVite-pluginPlugin } from '@nebula-db/vite-plugin';

// Create the plugin
const vite-pluginPlugin = createVite-pluginPlugin();

// Create a database with the plugin
const db = createDb({
  adapter: new MemoryAdapter(),
  plugins: [vite-pluginPlugin]
});

// Use the database with the plugin
const users = db.collection('users');
await users.insert({ name: 'Alice', age: 30 });
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://github.com/Nom-nom-hub/NebulaDB).

## License

MIT
npm package: @nebula-db/wasm
Description: WebAssembly support for NebulaDB
Author: Nom-nom-hub
Latest version: 0.2.3

# @nebula-db/wasm

WebAssembly support for NebulaDB

Part of the [NebulaDB](https://github.com/Nom-nom-hub/NebulaDB) project - a high-performance, reactive, TypeScript-first, schema-optional, embeddable NoSQL database.

## Installation

```bash
npm install @nebula-db/wasm
```

## Quick Start

```typescript
import { createDb } from '@nebula-db/wasm';
import { MemoryAdapter } from '@nebula-db/adapter-memory';

// Create a database with in-memory adapter
const db = createDb({
  adapter: new MemoryAdapter()
});

// Create a collection
const users = db.collection('users');

// Insert a document
await users.insert({ name: 'Alice', age: 30 });

// Query documents
const result = await users.find({ age: { $gt: 20 } });
console.log(result);
```

## Documentation

For full documentation, visit the [NebulaDB GitHub repository](https://github.com/Nom-nom-hub/NebulaDB).

## License

MIT
npm package: @nebula-os/types
Description: Tipos e interfaces compartilhados do NebulaOS
Latest version: 0.1.0

# @nebula-os/types

Tipos e interfaces compartilhados do NebulaOS.

## Instalação

```bash
npm install @nebula-os/types
# ou
pnpm add @nebula-os/types
```

## Uso

```typescript
import { IAgent, AgentConfig, ChatMessage } from "@nebula-os/types";

const config: AgentConfig = {
  name: "my-agent",
  instructions: "You are a helpful assistant",
};
```

## Tipos Disponíveis

- **Agent**: Tipos relacionados a agentes
- **Workflow**: Tipos relacionados a workflows
- **Tool**: Tipos relacionados a ferramentas
- **Memory**: Tipos relacionados a memória
- **Provider**: Tipos relacionados a providers LLM
- **Telemetry**: Tipos relacionados a telemetria
npm package: @nebula-services/rammerhead
Description: User friendly web proxy powered by testcafe-hammerhead
Author: Simon Cheng
Latest version: 1.2.41-holy.5

# rammerhead

> proxy based on testcafe-hammerhead (password is `sharkie4life`)

Demo link: https://demo-opensource.rammerhead.org

See [PACKAGE.md](./PACKAGE.md) for information on how to build this for your website-aio bundle.

Polished closed-source-for-now browser version: https://browser.rammerhead.org (more links by awesome community members in the discord server at the end of readme)

## Supporting me and contributing

Server infrastructure costs money and developing this project consumes a lot of my time, so I would appreciate it greatly if you become a Patreon member: https://www.patreon.com/rammerhead

## Who is this package for

Package is for those who want a fully-configurable proxy that works on many sites

## Effectiveness of proxy

This proxy supports proxying

-   basically everything except google logins

## Features of proxy

The proxy allows users to create a "session". When they access their session, their localStorage and cookies will be synced with rammerhead. This allows for accurately mocking cookied requests and conveniently save their logins even if they switch devices. This also enables users to configure a custom HTTP proxy server for rammerhead to connect to for the session.

## Installing and running

Rammerhead recommends you to have at least **node v16** to be installed. Once you installed nodejs, clone the repo, then run `npm install` and `npm run build`.

After, configure your settings in [src/config.js](src/config.js). If you wish to consistently pull updates from this repo without the hassle of merging, create `config.js` in the root folder so they override the configs in `src/`.

Finally run the following to start rammerhead: `node src/server.js`

## Discord server

For any user-help non-issue related questions, especially pertaining to Rammerhead Browser, please ask them here: [Rammerhead Support Server](https://discord.gg/VNT4E7gN5Y).
npm package: @nebula-services/ultraviolet
Description: Highly sophisticated proxy used for evading internet censorship or accessing websites in a controlled sandbox using the power of service-workers and more!
Latest version: 1.0.1-1.patch.7

<p align="center"><img src="https://raw.githubusercontent.com/titaniumnetwork-dev/Ultraviolet-Static/main/public/uv.png" height="250"></p>

<h1 align="center">Ultraviolet</h1>

<a href="https://www.npmjs.com/package/@titaniumnetwork-dev/ultraviolet"><img src="https://img.shields.io/npm/v/@titaniumnetwork-dev/ultraviolet.svg?maxAge=3600" alt="npm version" /></a>

Ultraviolet is a highly advanced web proxy used for evading internet censorship or accessing websites in a controlled sandbox. It is designed with security and performance in mind. Ultraviolet intercepts HTTP requests with a service worker, while adhering to the [TompHTTP specifications](https://github.com/tomphttp) and is a leader in innovative web proxy technologies.

## Features

Ultraviolet offers several features that set it apart from its predecessors, including CAPTCHA and hCAPTCHA support, URL encoding settings for added security, client-side configuration via service-workers, high speed compared to other web proxies, blacklist settings and more for easy hosting, leak prevention, regular updates, and improved resource usage and speed for better setups with a dedicated server instance.

## Supported Sites

Some of the popular websites that Ultraviolet supports include:

-   [Google](https://google.com)
-   [Youtube](https://www.youtube.com)
-   [Spotify](https://spotify.com)
-   [Discord](https://discord.com)
-   [Reddit](https://reddit.com)
-   [GeForce NOW](https://play.geforcenow.com/)
-   [now.gg](https://now.gg)

## Used by

-   [Holy Unblocker](https://github.com/holy-unblocker/website)
-   [Hypertabs](https://hypertabs.cc/)
-   [Terbium](https://github.com/TerbiumOS/webOS)
-   [Incognito](https://github.com/caracal-js/Incognito)
-   [Nebula](https://github.com/NebulaServices/Nebula)
-   [Metallic](https://github.com/Metallic-Web/Metallic)

## Changelog

Changes are documented in the [changelog](./CHANGELOG.md).

## Deployment

This repository can be built, but it can't be deployed to any services. See [Ultraviolet-App](https://github.com/titaniumnetwork-dev/Ultraviolet-App) for a complete and customizable Ultraviolet setup that you can deploy.

## Documentation

Documentation can be found in the [wiki](https://github.com/titaniumnetwork-dev/Ultraviolet/wiki).
npm package: @nebula-ui/package
Description: npm聚合类库
Latest version: 3.7.85

# Package 聚合依赖

聚合各个项目，外部模块使用 npm 安装依赖。

## 安装依赖

```bash
npm i @nebula-ui/package
```

## 项目引用

ESModule 引入各个模块

```javascript
import NebulaUI from "@nebula-ui/package/lib/nebula-ui/index.es.js";

import { createAccessService } from "@nebula-ui/package/lib/access/index.es.js";

import AliOSS from "@nebula-ui/package/lib/alioss/index.es.js";

import { createGrayService } from "@nebula-ui/package/lib/gray/index.es.js";

import { createHttpService } from "@nebula-ui/package/lib/http/index.es.js";

import icons from "@nebula-ui/package/lib/icons/index.es.js";

import Tinymce from "@nebula-ui/package/lib/tinymce/index.es.js";

import { vuePlugin, jsxPlugin } from "@nebula-ui/package/lib/vite/index.es.js";
```

Commonjs 引入各个模块

```javascript
import NebulaUI from "@nebula-ui/package/lib/nebula-ui/index.cjs.js";

import { createAccessService } from "@nebula-ui/package/lib/access/index.cjs.js";

import AliOSS from "@nebula-ui/package/lib/alioss/index.cjs.js";

import { createGrayService } from "@nebula-ui/package/lib/gray/index.cjs.js";

import { createHttpService } from "@nebula-ui/package/lib/http/index.cjs.js";

import icons from "@nebula-ui/package/lib/icons/index.cjs.js";

import Tinymce from "@nebula-ui/package/lib/tinymce/index.cjs.js";

import { vuePlugin, jsxPlugin } from "@nebula-ui/package/lib/vite/index.cjs.js";
```
npm package: @nebula.js/cli
Description: Command-line interface for nebula.js
Author: QlikTech International AB
Latest version: 6.8.0

# @nebula.js/cli

Command-line interface for nebula.js

## Install

```sh
npm install -g @nebula.js/cli
```

## Usage

```sh
nebula <command> [options]

Commands:
  nebula create <name>    Create a visualization
  / create mashup <name>  / Create a mashup
  nebula build            Build visualization
  nebula serve            Start a development server
  nebula sense            Build a nebula visualization as a Qlik Sense extension

Options:
  --version   Show version number                                      [boolean]
  -h, --help  Show help                                                [boolean]
```

## How to use nebula CLI in your visualization

You can use the package.json script variant of these commands, which are exposed for you with`nebula create`

When you want to make the `nebula serve`, `nebula build`, and `nebula sense` commands available in your visualization by yourself, run the following command.

```bash
npm install @nebula.js/cli @nebula.js/cli-build @nebula.js/cli-sense @nebula.js/cli-serve
```

or

```bash
yarn add @nebula.js/cli @nebula.js/cli-build @nebula.js/cli-sense @nebula.js/cli-serve
```

Open up your package.json, those dependencies are added.

```json
{
  "devDependencies": {
    "@nebula.js/cli": "latest",
    "@nebula.js/cli-build": "latest",
    "@nebula.js/cli-sense": "latest",
    "@nebula.js/cli-serve": "latest"
  }
}
```

and add a script like so:

```json
"scripts": {
    "build": "nebula build",
    "start": "nebula serve",
    "sense": "nebula sense"
  },
```

You can also run nebula cli commands with Node.js. Create a js file called build.js
and add the following:

```js
const build = require('@nebula.js/cli-build');
const sense = require('@nebula.js/cli-sense');

await build({
  config: '../nebula.config.js',
  sourcemap: false,
  core: 'core',
  mode: 'production',
  watch: false,
});
await sense({ output: 'sn-table-ext', sourcemap: true });
```

and run the following command:

```bash
node build.js
```

## How to test your modified nebula CLI locally and globally

Requirements:

- Node.js
- yarn

Clone the repository:

```sh
git clone https://github.com/qlik-oss/nebula.js
```

From the root directory, run the following command to install all the necessary dependencies of nebula CLI:

```sh
yarn
```

You can modify code in commands directory and do the following to test modified nebula CLI locally and globally:

### Test nebula CLI locally

Run nebula CLI locally to see help info using node.js:

```sh
cd commands/cli
node lib/index.js -h
```

### Test nebula CLI globally

From the commands/cli directory, run the following command to create a global symlik to the binary:

```sh
yarn link
```

Run nebula CLI globally to see help info to check whether it works:

```sh
nebula -h
```

Tips:

If 'There's already a package called "@nebula.js/cli" registered.' or 'command not found: nebula' is displayed.

Run the following command to remove the symlinked nebula and run 'yarn link' again:

```sh
yarn unlink
```
npm package: @nebula.js/cli-create
Description: Scaffold a nebula visualization or mashup.
Author: QlikTech International AB
Latest version: 6.8.0

# @nebula.js/cli-create

Scaffold a nebula visualization or mashup.

## Install

```sh
npm install -g @nebula.js/cli
```

## Usage

### CLI

```sh
nebula create <name>

Create a visualization

Commands:
  nebula create mashup <name>  Create a mashup

Positionals:
  name  name of the project                                  [string] [required]

Options:
  --version   Show version number                                      [boolean]
  --install   Run package installation step            [boolean] [default: true]
  --pkgm      Package manager          [string] [choices: "npm", "yarn", "pnpm"]
  --picasso   Picasso template [string] [choices: "none", "minimal", "barchart"]
  --author    Package author                                            [string]
  -h, --help  Show help                                                [boolean]
```

```sh
nebula create mashup <name>

Create a mashup

Positionals:
  name  name of the project                                  [string] [required]

Options:
      --version  Show version number                                   [boolean]
      --install  Run package installation step         [boolean] [default: true]
      --pkgm     Package manager       [string] [choices: "npm", "yarn", "pnpm"]
      --picasso  Picasso template
                               [string] [choices: "none", "minimal", "barchart"]
      --author   Package author                                         [string]
  -h, --help     Show help                                             [boolean]
```

### Example

#### Create a visualization

```sh
nebula create hello-sunshine
```

Running nebula create without --picasso prompts a selection of the available
options.

- none: without the picasso.js template
- minimal: a basic setup of picasso.js is ready
- barchart: a bar chart component created by picasso.js is ready

You can find the [tutorial](https://qlik.dev/extend/extend-quickstarts/first-extension) to build a basic nebula visualization using nebula.js.

#### Create a mashup

```sh
nebula create mashup hello-mashie
```

You can find the [tutorial](https://qlik.dev/embed/integrate-web-apps/build-a-simple-mashup) to build a basic mashup using nebula.js.

#### Package manager

Create a nebula visualization project called `sn-table` with the npm package manager
instead of yarn

```sh
nebula create sn-table --pkgm npm
```

Create a mashup called `table-mashup` with the npm package manager instead of yarn

```sh
nebula create mashup table-mashup --pkgm npm
```

#### Package installation step

Create a nebula visualization project and do not install any dependencies yet

```sh
nebula create sn-table --install false
```

Create a mashup and do not install any dependencies yet

```sh
nebula create mashup table-mashup --install false
```
npm package: @nebula.js/sn-action-button
Description: Action button supernova
Author: QlikTech International AB
Latest version: 2.2.6

# sn-action-button

Action button supernova for nebula.js

![Action button preview](./assets/preview.gif)

## Installing

If you use npm: `npm install @nebula.js/sn-action-button`. You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-action-button).

## Usage

```js
import { embed } from '@nebula.js/stardust';
import actionButton from '@nebula.js/sn-action-button';

// 'app' is an enigma app model
const nuked = embed(app, {
  types: [{ // register the action button object
    name: 'action-button',
    load: () => Promise.resolve(actionButton);
  }]
});

nuked.render({
  element,
  type: 'action-button',
});
```
npm package: @nebula.js/sn-animator
Description: Control for iterating over a dimension with a set time between each step.
Author: QlikTech International AB
Latest version: 2.13.0

# ! Experimental

[![CircleCI](https://circleci.com/gh/qlik-trial/sn-animator/tree/master.svg?style=svg&circle-token=e67f11435d0581b451b81e2656d973dabfec6e7f)](https://circleci.com/gh/qlik-trial/sn-animator/tree/master)
[![Maintainability](https://api.codeclimate.com/v1/badges/123f7e0d8098f79c2d0e/maintainability)](https://codeclimate.com/repos/6141babf63a6cf014c015572/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/123f7e0d8098f79c2d0e/test_coverage)](https://codeclimate.com/repos/6141babf63a6cf014c015572/test_coverage)

# sn-animator

## An animator for nebula.js.

The animator values over a dimension. The animator is normally used to observe relationships among charts.

![Animator example](./assets/preview.png)

## Requirements

Requires `@nebula.js/stardust` version `1.2.0` or later. You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-animator).

## Installing

If you use npm: `npm install @nebula.js/sn-animator`.

## Usage

```js
import { embed } from '@nebula.js/stardust';
import animator from '@nebula.js/sn-animator';

// 'app' is an enigma app model
const nuked = embed(app, {
  types: [
    {
      // register the animator
      name: 'animator',
      load: () => Promise.resolve(animator),
    },
  ],
});

// Rendering a animator on the fly
nuked.render({
  type: 'animator',
  element,
});
```

More details can be found in the `examples` folder.

## Release the Animator chart

#### Publish package
New packages should be published by Circle CI and it will publish a new release if the package.json version matches the tag. Ie `package.json = 2.0.0 && tag = v2.0.0`.
The simplest way to accomplish this is to follow the steps below. Also don't forget to resolve/close all appropriate JIRA issues.

- Make sure `origin/master` (github master) has all changes that should be included in the release.
- Ensure you have clean and up to date local master.
- Run one of the following commands depending on what type of release it is you want to make

A standard release is made with (if you're not sure, this is the one you want).
- `yarn minor-release`

For a major release with breaking changes
- `yarn major-release`

For a patch release in a release branch
- `yarn patch-release`

You can use this command to make a pre-release. Use it in your branch to not affect the version in master and be sure to revert back to the master's version when you create the PR.
- `yarn pre-release`
npm package: @nebula.js/sn-distributionplot
Description: Distributionplot supernova
Author: QlikTech International AB
Latest version: 1.0.6

# @nebula.js/sn-distributionplot

The distribution plot is suitable for comparing range and distribution for groups of numerical data. Data is plotted as value points along an axis.

## Requirements

Requires `@nebula.js/stardust` version `1.4.0` or later.

## Installing

If you use pnpm: `pnpm install @nebula.js/sn-distributionplot`. You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-distributionplot).

## Usage

In a distribution plot you need to use one or two dimensions, and one measure. If you use a single dimension you will receive a single line visualization. If you use two dimensions, you will get one line for each value of the second, or outer, dimension.

```js
import { embed } from '@nebula.js/stardust';
import distributionplot from '@nebula.js/sn-distributionplot';

// 'app' is an enigma app model
const embeddable = embed(app, {
  types: [
    {
      // register distribution plot chart
      name: 'distributionplot',
      load: () => Promise.resolve(distributionplot),
    },
  ],
});

embeddable.render({
  element,
  type: 'distributionplot',
  fields: ['Product Sub Group', 'Product Group', '=Avg(Sales)'],
});
```

## More examples

### Vertical distribution plot

Setting `orientation` property value to `vertical`. Default value is `horizontal`.

```js
embeddable.render({
  element,
  type: 'distributionplot',
  fields: ['Product Sub Group', 'Product Group', '=Avg(Sales)'],
  // overrides default properties
  properties: {
    orientation: 'vertical',
  },
});
```

### Different ways to present distribution plot

#### Points only

Displays value points only.

```js
embeddable.render({
  element,
  type: 'distributionplot',
  fields: ['Product Sub Group', 'Product Group', '=Avg(Sales)'],
  // overrides default properties
  properties: {
    presentation: {
      visibleComponents: 'points',
    },
  },
});
```

#### Background only

Displays a bounding box showing the range of the values only.

```js
embeddable.render({
  element,
  type: 'distributionplot',
  fields: ['Product Sub Group', 'Product Group', '=Avg(Sales)'],
  // overrides default properties
  properties: {
    presentation: {
      visibleComponents: 'box',
    },
  },
});
```

#### Bubble size and jitter

You can adjust the size of the bubbles that illustrate the value points by setting `bubbleScales` value.

You can set `displacement` to `jitter` to jitter several overlapping value points. This moves some of the points slightly to create a larger footprint that shows that there are more than one value behind the point.

```js
embeddable.render({
  element,
  type: 'distributionplot',
  fields: ['Product Sub Group', 'Product Group', '=Avg(Sales)'],
  // overrides default properties
  properties: {
    dataPoint: {
      bubbleScales: 90,
      displacement: 'jitter',
    },
  },
});
```
npm package: @nebula.js/sn-histogram
Description: Histogram supernova
Author: QlikTech International AB
Latest version: 1.0.6

# @nebula.js/sn-histogram

The histogram is suitable for visualizing distribution of numerical data over a continuous interval, or a certain time period. The data is divided into bins, and each bar in a histogram represents the tabulated frequency at each bin.

## Requirements

Requires `@nebula.js/stardust` version `1.4.0` or later.

## Installing

If you use pnpm: `pnpm install @nebula.js/sn-histogram`. You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-histogram).

## Usage

```js
import { embed } from '@nebula.js/stardust';
import histogram from '@nebula.js/sn-histogram';

// 'app' is an enigma app model
const embeddable = embed(app, {
  types: [
    {
      // register histogram chart
      name: 'histogram',
      load: () => Promise.resolve(histogram),
    },
  ],
});

embeddable.render({
  element,
  type: 'histogram',
  fields: ['City Code'],
  }
});
```

## More examples

### Number of bars

Set maximum number to the number of bars you want to divide the data into. Setting `binMode` property to `maxCount` and set `binCount` to the number of bars that you want the chart to display.

```js
embeddable.render({
  element,
  type: 'histogram',
  fields: ['City Code'],
  // overrides default properties
  properties: {
    bins: {
      auto: false,
      binMode: 'maxCount',
      binCount: 5,
      binSize: 10,
      offset: 0,
      countDistinct: false,
    },
  },
});
```

### Bar width (x-axis)

Set width to define how wide each bar is. This is based on the values on the x-axis. You can offset the bars by changing the Offset setting. If you set Width to 2 and keep the default Offset setting 0, your bars may be defined 0 to 2, 2 to 4, 4 to 6, and so on. If you change Offset to 1, the bars are defined -1 to 1, 1 to 3, 3 to 5, and so on.

Setting `binMode` property to `size` and set `binSize` and `offset` to desired numbers.

```js
embeddable.render({
  element,
  type: 'histogram',
  fields: ['City Code'],
  // overrides default properties
  properties: {
    bins: {
      auto: false,
      binMode: 'size',
      binCount: '',
      binSize: 15,
      offset: 5,
      countDistinct: false,
    },
  },
});
```

### Count distinct values only

Setting `countDistinct` property to `true` to exclude duplicate values.

<!-- ![image info](./assets/sn-histogram-chart-count-distinct.png)-->

```js
embeddable.render({
  element,
  type: 'histogram',
  fields: ['City Code'],
  // overrides default properties
  properties: {
    bins: {
      auto: true,
      binMode: 'maxCount',
      binCount: '',
      binSize: 10,
      offset: 0,
      countDistinct: true,
    },
  },
});
```
npm package: @nebula.js/sn-kpi
Description: KPI supernova
Author: QlikTech International AB
Latest version: 2.4.0

# @nebula.js/sn-kpi

A KPI supernova, based on the Qlik Sense nativa KPI object.

[![Maintainability](https://qlty.sh/badges/3f3764ba-9fe4-4be4-850f-dc3e872f77f6/maintainability.svg)](https://qlty.sh/gh/qlik-trial/projects/sn-kpi)
[![Code Coverage](https://qlty.sh/badges/3f3764ba-9fe4-4be4-850f-dc3e872f77f6/coverage.svg)](https://qlty.sh/gh/qlik-trial/projects/sn-kpi)

![KPI preview](./assets/preview.png)

## Contribution

Instructions for developing and releasing can be found in the [contribution document](.github/CONTRIBUTION.md)

## Installing

If you use npm: `npm install @nebula.js/sn-kpi`.

You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-kpi).

## Usage

```js

import { embed } from '@nebula.js/stardust';
import kpi from '@nebula.js/sn-kpi';

// 'app' is an enigma app model
const nuked = embed(app, {
  types: [{ // register the kpi
    name: 'kpi',
    load: () => Promise.resolve(kpi);
  }]
});

nuked.render({
  element,
  type: 'kpi',
});
```
npm package: @nebula.js/sn-layout-container
Description: The layout container object has a canvas that can hold multiple objects. In this container you can freely move objects around, as well as position the objects on top of each other or overlapping.
Author: QlikTech International AB
Latest version: 4.0.5

# sn-layout-container

The layout container is a [nebula](https://qlik.dev/extend/set-up-nebula-environment) based chart that allows for free form layouting of child objects/charts.

## Contribution

Information about developing and contributing can be found in our [contribution guide](../../.github/CONTRIBUTION.md).

## Usage

```js
npm install sn-layout-container
```
npm package: @nebula.js/sn-mekko-chart
Description: Compare the share of values using variable width of stacked bars
Author: QlikTech International AB
Latest version: 1.4.7

# `sn-mekko-chart` &thinsp; [![coverage.badge]][coverage] ![maintainability]

[coverage.badge]: https://qlty.sh/badges/e05a8e32-e7f6-4b9a-8ba4-5c980bafd409/test_coverage.svg
[coverage]: https://qlty.sh/gh/qlik-trial/projects/sn-mekko-chart
[maintainability]: https://qlty.sh/badges/e05a8e32-e7f6-4b9a-8ba4-5c980bafd409/maintainability.svg

A basic mekko chart supernova aimed to be used in [nebula.js](https://github.com/qlik-oss/nebula.js).

```js

import { embed } from '@nebula.js/stardust';
import mekko from '@nebula.js/sn-mekko-chart';

// 'app' is an enigma app model
const embeddable = embed(app, {
  types: [{ // register the mekko chart
    name: 'mekko',
    load: () => Promise.resolve(mekko);
  }]
});

embeddable.render({
  element,
  type: 'mekko',
  fields: ['Region', 'Fiscal Year', '=Sum(Sales)'],
});
```

## Requirements

Requires `@nebula.js/stardust` version `>=1.7.0`.

## Installing

If you use npm: `npm install @nebula.js/sn-mekko-chart`. You can also load through the script tag directly from any of the CDNs that supports NPM packages, for example: [unpkg](https://unpkg.com/@nebula.js/sn-mekko-chart).

## More examples

### Color by dimension

In this example the first dimension (Region) is used to color each cell.

```js
embeddable.render({
  element,
  type: "mekko",
  fields: ["Region", "Fiscal Year", "=Sum(Sales)"],
  properties: {
    cellColor: {
      mode: "byDimension",
      byDimension: { type: "index", typeValue: 0 },
    },
  },
});
```

## API

The API specifiction is available at [Qlik Developer Portal](https://qlik.dev/apis/javascript/nebula-mekko-chart)
npm package: @nebula.js/sn-nav-menu
Description: A navigation menu object for Qlik Sense
Author: QlikTech International AB
Latest version: 0.14.1

# sn-nav-menu

## !Experimental

A navigation menu object for Qlik Sense implemented as a nebula.js supernova.

## Developing

- Install with `pnpm install`
- Transpile code: `pnpm build` (or `pnpm build:watch`)
- Run it using nebula serve `pnpm start`

## Testing

Run unit tests with:

`pnpm test:unit`

# Rendering tests

Rendering tests are running playwright. Execute rendering tests with `pnpm test:e2 --headed`.

Rendering test compares a baseline snapshot with a current version of the same object. The output is then stored under `baselines`. It is important to take the baseline from the build in your PR and not your local baselines which is stored under `baselines-local`. The report with baselines can be found under summary under a link called test report.

You can use the action called update snapshot to trigger a commit into your branch that automatically updates the snapshots.

1. Go to actions tab
2. Click on Build, validate, (release) workflow
3. Open the Run workflow dropdown menu to the right
4. Choose your branch and tick the update_snapshot
5. Click Run workflow - now a commit will be done to your branch with updated snapshots

## Linting

Run lint with:

`pnpm lint`

## Releasing

Trigger the github action `Build, validate, (release)` and make sure you tick the `release` checkbox.
npm package: @nebula.js/sn-network-chart
Description: Displays hierarchical or relational dimensions as nodes and edges´, with measures to show the significance of its links.
Author: QLIK
Latest version: 1.0.7

# sn-network-chart

A network chart to be used with nebula.js, built using [visjs network visualization](https://github.com/visjs/vis-network) to display networks of nodes and edges.

## Requirements

Requires `@nebula.js/stardust` version `1.7.0` or later.

## Installing

If you use npm: `npm install @nebula.js/sn-network-chart`.

You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-network-chart).

## Usage

```js
import { embed } from '@nebula.js/stardust';
import network from '@nebula.js/sn-network-chart';

// 'app' is an enigma app model
const nuked = embed(app, {
  types: [
    {
      // register grid chart - qlik-network-chart is the default name in sense
      name: 'qlik-network-chart',
      load: () => Promise.resolve(network),
    },
  ],
});

// Rendering a simple network chart
nuked.render({
  element: document.querySelector('.network'),
  type: 'qlik-network-chart',
  fields: ['Source', 'Target', '=Sum(Flow)'],
  properties: {
    title: 'Visualization of network flows',
  },
});
```

## Data sample

Check `resources/Network data.xlsx` for an example. The simplest data form is where each row represents an edge in the network. Take this example of airport connections:

| AirportID | AirportName    | LinkToId | Volume |
|-----------|----------------|----------|--------|
| 0         | Soekarno-Hatta | 3        | 23000  |
| 1         | Halim          | 0        | 5460   |
| 2         | Changi         | 0        | 10870  |
| 3         | KLCC           | 1        | 2780   |
| 4         | Don Muang      | 1        | 4800   |
| 4         | Don Muang      | 2        | 7800   |

Sense inline load script example:

```
Load * Inline [
AirportID, AirportName, LinktoID,Volume
0,Soekarno-Hatta,3,23000
1,Halim,0,5460
2,Changi,0,10870
3,KLCC,1,2780
4,Don Muang,1,4800
4,Don Muang,2,7800
];
```

# Original Author
**Michael Laenen**
* [github.com/miclae76](https://github.com/miclae76)

# Contributors
**Göran Sander**
* [github.com/mountaindude](https://github.com/mountaindude)
npm package: @nebula.js/sn-org-chart
Description: Org chart supernova
Author: QlikTech International AB
Latest version: 1.4.2

# sn-org-chart

Organizational chart for use with Qlik's Analytics Platform.

![Org chart](./assets/preview.png)

## Installing

Install as npm package: `npm install @nebula.js/sn-org-chart`.

You can also load through the script tag directly from [https://unpkg.com](https://unpkg.com/@nebula.js/sn-org-chart).

## Usage

```js

import { embed } from '@nebula.js/stardust';
import org from '@nebula.js/sn-org-chart';

// 'app' is an enigma app model
const nuked = embed(app, {
  types: [{
    name: 'orgchart',
    load: () => Promise.resolve(org);
  }]
});

embed.render({
  element,
  type: 'orgchart',
});
```