open-index/open-npm huggingface dataset:
npm package: @nebula.js/sn-shape
Description: Add vertical or horizontal lines with adjustable color and size. Use lines to divide objects, group parts, or to add flair to your dashboard.
Author: QlikTech International AB
Latest version: 1.1.13

# sn-shape

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

<!--
![shape chart preview](./assets/sn-shape.png)
-->

```js

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

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

embeddable.render({
  element,
  type: 'shape',
  properties: {
    shape: {
      type: "line",
      orientation: "vertical",
      style: {
        width: 3,
        color: {
          color: "#ff00ff",
        },
      }
    }
  }
});
```

## Requirements

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

## Installing

If you use npm: `npm install @nebula.js/sn-shape`. 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-shape).

<!--
## API


The API specifiction is available at [Qlik Developer Portal](https://qlik.dev/apis/javascript/nebula-shape-chart)
-->

## Release

To trigger a release, manually run the workflow on a release branch and set release to true.
For more info on actions / github workflows see: https://github.com/qlik-oss/sn-gh-workflows/
npm package: @nebula.js/sn-tabbed-container
Description: A container that lets you scroll through charts by using tabs.
Author: QlikTech International AB
Latest version: 2.0.5

# sn-tabbed-container

The tabbed container is a [nebula](https://qlik.dev/extend/set-up-nebula-environment) based chart that allows you to switch between charts by using a tab bar.

## Contribution

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

## Usage

```js
npm install sn-tabbed-container
```

## Rendering tests

Temporarily, in order to produce/update the linux snapshots, change the "test:e2e": "playwright test" script to "test:e2e": "playwright test --update-snapshots" and let the CI of the PR to produce them before reverting back this change.

The proper solution we need to follow is the one implemented in the nebula-tables (https://github.com/qlik-trial/nebula-tables/blob/main/packages/sn-table/package.json#L38) but currently they are throwing error: Error occured while trying to proxy: localhost:8078/render?....
npm package: @nebula.js/sn-text
Description: Display text, links, and measures. Add tables with rows and columns. Format and color the text. Add background image and color.
Author: QlikTech International AB
Latest version: 1.7.2

# sn-text

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

```js

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

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

embeddable.render({
  element,
  type: 'text',
  properties: {
    text: "{\"root\":{\"children\":[{\"children\":[{\"detail\":0,\"format\":0,\"mode\":\"normal\",\"style\":\"\",\"text\":\"This is some text\",\"type\":\"text\",\"version\":1}],\"direction\":\"ltr\",\"format\":\"\",\"indent\":0,\"type\":\"paragraph\",\"version\":1}],\"direction\":\"ltr\",\"format\":\"\",\"indent\":0,\"type\":\"root\",\"version\":1}}"
  }
});
```

## Requirements

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

## Installing

If you use npm: `pnpm install @nebula.js/sn-text`. 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-text).

<!--
## API

The API specifiction is available at [Qlik Developer Portal](https://qlik.dev/apis/javascript/nebula-shape-chart)
-->

## Release

To trigger a release, manually run the build workflow on a release branch and set release to true.
For more info on actions / github workflows see: https://github.com/qlik-oss/sn-gh-workflows/
npm package: @nebula.js/sn-treemap
Description: Treemap supernova that is DOM independent
Author: Qlik
Latest version: 1.7.3

# sn-treemap

### Releasing

Run the `Build` action on the desired branch with the `release` checkbox ticked.

# Rendering tests
 
 Rendering tests are running playwright. Execute rendering tests with `pnpm test:e2e --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.
npm package: @nebula.js/sn-video-player
Description: Control for playing video content.
Author: QlikTech International AB
Latest version: 0.18.0

[![CircleCI](https://circleci.com/gh/qlik-trial/sn-video-player.svg?style=svg&circle-token=fd043b94f0d67f89895c0223a0fb0062d357d921)](https://app.circleci.com/pipelines/github/qlik-trial/sn-video-player)
# sn-video-player

Video player extension for Qlik Sense.

Based on [videojs](https://videojs.com/) and using a plugin for playing youtube content(removed in v0.17.0). _**Note**_ that youtube cookies will be added even if we utilize youtube-nocookie.com end point. (valid for < v0.17.0)

## How to release

1. Make sure you are on master branch
2. Run `npm run major/minor/patch-release`
3. Wait for CircleCi pipeline to turn green
npm package: @nebula.js/sn-word-cloud
Description: A graphic representation of a text dimension where size is based on the measure value
Author: QLIK
Latest version: 1.0.8

# sn-word-cloud
A word cloud chart aimed to be used in nebula.js built using d3 and d3-cloud.

This extension is part of the extension bundles for Qlik Sense. The repository is maintained and moderated by Qlik R&D.
## Requirements

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

## Installing

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

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

## Usage

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

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

// Rendering a simple word cloud
nuked.render({
  element: document.querySelector('.wordCloud'),
  type: 'qlik-word-cloud',
  fields: ['WordsField', '=Sum(SizeField)'],
  properties: {
    title: 'Word cloud',
  },
});
```

## License

`@nebula.js/sn-word-cloud` is [MIT licensed](./LICENSE).

## Original author

[github.com/cleveranjos](https://github.com/cleveranjos)
npm package: @nebula.js/stardust
Description: Product and framework agnostic integration API for Qlik's Associative Engine
Author: QlikTech International AB
Latest version: 6.8.0

# stardust

Stardust is a JavaScript library for building and embedding visualizations on top of Qlik's Associative Engine.

## Installation

```sh
npm install @nebula.js/stardust
```

## Example usage

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

const orion = embed.createConfiguration({
  types: [{
    name: 'mekko',
    load: () => Promise.resolve(mekko);
  }]
})(app);

orion.render({
  element,
  type: 'mekko',
  fields: ['Product', 'Region', 'Sales']
});
```

## Typescript

Stardust comes with typescript definitions. It references the Qlik's Engine definitions published at @types/qlik-engineapi.

When installing Stardust it also installs the package @types/qlik-engineapi. Use [overrides](https://docs.npmjs.com/cli/v8/configuring-npm/package-json#overrides) in your package.json if the installed version deviates from the Qlik Engine you are using:

```json
{
  "overrides": {
    "@types/qlik-engineapi": "<your-engine-version>"
  },
  ...
}
```
npm package: @nebula2003/cmd-alias
Description: Alias Command Tool is a powerful CLI utility that simplifies your workflow by allowing you to create and execute custom command aliases at the directory level. By reading aliases from a configuration file (r.config.json), it enables developers and power u
Author: Tejus Raghavendra
Latest version: 1.0.4

# Alias Command Tool

Alias Command Tool is a powerful CLI utility that simplifies your workflow by allowing you to create and execute custom command aliases at the directory level. By reading aliases from a configuration file (r.config.json), it enables developers and power users to run complex commands effortlessly with simple, predefined aliases.

## Features

-   Define and execute command aliases at the directory level.
-   Automatically redirect command output to the terminal.

## Installation

To install the Alias Command Tool globally, run:

```sh
npm install -g @nebula2003/cmd-alias
```

## Usage

1. Create a Configuration File
   In the directory where you want to use your aliases, create an r.config.json file. This file will contain your command aliases and settings.

    ```json
    {
        "gf": "git fetch --all",
        "sl": "npm run start:local",
        "test": "npm run test"
    }
    ```

2. Run an Alias
   To run an alias, use the `c` command followed by the alias name.

    ```sh
    c gf
    ```

    This will execute the `git fetch --all` command.
npm package: @nebula2003/generator-express
Description: This is a Node.js package for generating an Express app. It provides a command-line interface for creating a new Express app with a basic file structure and configuration.
Author: Tejus
Latest version: 1.1.2

# Express App Generator

This is a Node.js package for generating an Express app. It provides a command-line interface for creating a new Express app with a basic file structure and configuration.

## Installation

To install the package, run the following command:

```bash
npm i -g @nebula2003/generator-express
```

## Usage

To create a new Express app, run the following command:

```bash
generatorExpress create app <path>
```

To add a new Service, run the following command:

```bash
generatorExpress add-service <name> <path>
```

## Running the Application

To run the application with Babel transpilation and PM2 process manager, follow these steps:

1. Install dependencies:

```bash
npm i
```

2. Run the application:

```bash
npm start
```

3. To stop the application, run the following command:

```bash
npm stop
```

**Note:** The application requires PM2 to be installed globally. To install PM2 globally, run the following command:

```bash
npm i -g pm2
```

**Note:** The ES6 version of this Express app includes Babel for compatibility with older packages that use `require`. Make sure to follow the steps in the [Running the Application](#running-the-application) section to set up and run the application with Babel and PM2.
npm package: @nebulaai/capitalize-first
Description: Capitalize the first letter of a string
Author: Jorge Gonzalez
Latest version: 0.1.1

# 🌟 capitalize-first

**One letter. Maximum impact. Make every string start like it means business.**

*Pure string power from the NebulaAI arsenal*

---

## ⚡ Get Started (Lightning fast)

```bash
npm install @nebulaai/capitalize-first
```

## 🔥 Watch the magic happen

```typescript
import { capitalizeFirst } from "@nebulaai/capitalize-first";

// Transform user input like a pro
capitalizeFirst("hello world");        // → "Hello world"
capitalizeFirst("SCREAMING TEXT");     // → "SCREAMING TEXT" 
capitalizeFirst("camelCaseStuff");     // → "CamelCaseStuff"
capitalizeFirst("99 problems");        // → "99 problems"

// Perfect for UI polish
const userName = "sarah_dev_2024";
const displayName = capitalizeFirst(userName);  // → "Sarah_dev_2024"
```

## 🚀 Why developers choose this

- **Microscopic bundle**: Adds literally nothing to your build size
- **Bulletproof**: Handles edge cases you forgot existed
- **TypeScript native**: IntelliSense that actually helps
- **Zero deps**: No dependency hell, ever
- **Works everywhere**: Node, Deno, Bun, browsers - anywhere JS runs

## 🛠️ API That Never Fails

```typescript
capitalizeFirst(str: string): string
```

| Input | Output | Vibe Check |
|-------|--------|------------|
| `"hello"` | `"Hello"` | ✨ Clean |
| `"HELLO"` | `"HELLO"` | 🎯 Smart |
| `""` | `""` | 🛡️ Safe |

**Pro move:** Handles empty strings, weird unicode, and everything in between without breaking a sweat.

---

## 🎯 Perfect for

- **User-facing text** → Professional first impressions
- **Form validation** → Clean up messy input instantly  
- **Content management** → Consistent formatting everywhere
- **API responses** → Polish data before it hits the frontend
- **Template strings** → Dynamic content that looks intentional

## 💡 Before vs After

```typescript
// Before: Manual, error-prone, forgettable
function makeNice(str) {
  if (!str) return str;
  return str.charAt(0).toUpperCase() + str.slice(1);
}

// After: One import, infinite confidence
import { capitalizeFirst } from "@nebulaai/capitalize-first";
const result = capitalizeFirst(userInput);  // Just works ™️
```

---

## 📄 License

MIT © Jorge Gonzalez / Temporal AI Technologies Inc.

*Empowering developers to build better, faster, cleaner*
npm package: @nebulaai/charts
Description: Comprehensive charting library with real-time updates and interactive visualizations
Author: NebulaAI
Latest version: 1.0.3


# @nebulaai/charts

Comprehensive charting library with real-time updates and interactive visualizations for NebulaAI applications.

## Installation

```bash
npm install @nebulaai/charts
```

## Quick Start

```tsx
import { LineChart, generateRandomData } from '@nebulaai/charts';

const data = generateRandomData(10);
const series = [{ name: 'Sample Data', data }];

function App() {
  return (
    <LineChart 
      series={series}
      width={800}
      height={400}
      theme="light"
    />
  );
}
```

## Features

- 📊 Multiple chart types (Line, Bar, Area, Scatter)
- 🔄 Real-time data updates
- 🎨 Light/Dark themes
- 📱 Responsive design
- ⚡ High performance canvas rendering
- 🎯 Interactive data points
- 📈 Time series support

## Chart Types

- `LineChart` - Line charts with smooth curves
- `BarChart` - Vertical/horizontal bar charts
- `AreaChart` - Filled area charts
- `ScatterChart` - Scatter plots
- `RealTimeChart` - Live updating charts

## License

MIT
npm package: @nebulaai/cli-core
Description: Core CLI infrastructure and utilities for NebulaAI command-line tools
Author: Jorge Gonzalez & Temporal AI Technologies Inc
Latest version: 1.0.0


# @nebulaai/cli-core

Core CLI infrastructure and utilities for NebulaAI command-line tools.

## Features

- Extensible CLI framework
- Built-in command registration
- Colored output and progress indicators
- Error handling and validation
- Commander.js integration

## Installation

```bash
npm install @nebulaai/cli-core
```

## Usage

```typescript
import { createCLI, CLIConfig } from '@nebulaai/cli-core';

const config: CLIConfig = {
  name: 'my-cli',
  version: '1.0.0',
  description: 'My CLI application',
  commands: [
    {
      name: 'hello',
      description: 'Say hello',
      action: (args, options) => {
        console.log('Hello, world!');
      }
    }
  ]
};

const cli = createCLI(config);
cli.run();
```

## API Reference

### createCLI(config: CLIConfig)

Creates a new CLI instance with the provided configuration.

### NebulaAICLI

Main CLI class that handles command registration and execution.

## Contributing

We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Author

Jorge Gonzalez & Temporal AI Technologies Inc
npm package: @nebulaai/get-random-element
Description: 🎲 One function. Infinite possibilities. Pick random elements like a boss.
Author: Jorge Gonzalez
Latest version: 1.0.0

# 🎲 get-random-element

**One function. Infinite possibilities. Pick random elements like a boss.**

*Level up your randomness game with NebulaAI*

---

## 🚀 Get Started (30 seconds)

```bash
npm install @nebulaai/get-random-element
```

## 🔥 See it in action

```typescript
import { getRandomElement } from "@nebulaai/get-random-element";

// Pick your fighter
const fighters = ["🥷", "🦸‍♀️", "🤖", "🧙‍♂️"];
getRandomElement(fighters);  // → "🤖" (maybe?)

// Random UI colors
const palette = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#96ceb4"];
getRandomElement(palette);   // → "#4ecdc4"

// Surprise your users
const loadingMessages = [
  "Brewing coffee...", 
  "Feeding hamsters...", 
  "Calculating universe..."
];
getRandomElement(loadingMessages);  // → "Feeding hamsters..."
```

## ⚡ Why devs love this

- **Type-safe**: Full TypeScript support out the box
- **Zero dependencies**: No bloat, just pure randomness  
- **Works everywhere**: Node, browser, React, Vue - you name it
- **Battle-tested**: Used in production by thousands of apps

## 🛠️ API That Just Works

```typescript
getRandomElement<T>(arr: T[]): T
```

| What goes in | What you get | Magic level |
|--------------|--------------|-------------|
| `T[]` (any array) | `T` (random item) | 🔮 Maximum |

**Pro tip:** Works with literally anything - strings, objects, functions, memes, you name it.

---

## 🎯 Perfect for

- **Randomizing user experiences** → Keep things fresh
- **A/B testing** → Easy feature flags  
- **Game development** → RNG that actually works
- **Creative coding** → Unexpected combinations
- **Loading states** → Fun messages that don't suck

## 💡 Level up your code

```typescript
// Before: Boring, predictable, sad
const message = "Loading...";

// After: Dynamic, engaging, chef's kiss
const messages = ["🚀 Launching...", "⚡ Powering up...", "🎨 Creating magic..."];
const message = getRandomElement(messages);
```

---

## 📄 License

MIT © Jorge Gonzalez / Temporal AI Technologies Inc.

*Built for the next generation of developers who demand better tools*
npm package: @nebulaai/lumina-ui
Description: Enterprise-grade glass morphism UI components with neural-inspired design system
Author: Temporal AI Technologies
Latest version: 1.0.1


# 🌟 Lumina UI

*Enterprise-grade glass morphism UI components for React*

[![NPM Version](https://img.shields.io/npm/v/@sp3ctrum/lumina-ui)](https://www.npmjs.com/package/@sp3ctrum/lumina-ui)
[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)](https://www.typescriptlang.org/)

## 🚀 Quick Start

```bash
npm install @sp3ctrum/lumina-ui
```

```tsx
import { Button, GlassCard } from '@sp3ctrum/lumina-ui'
import '@sp3ctrum/lumina-ui/styles'

function App() {
  return (
    <GlassCard className="p-6">
      <h1>Hello Lumina!</h1>
      <Button variant="glass">Click me</Button>
    </GlassCard>
  )
}
```

## 📦 What's Included

### Glass Components
- `GlassCard` - Beautiful glass-effect containers
- `FloatingActionButton` - Floating buttons with depth
- `GlassEffect` - Apply glass morphism to any element

### Interactive Elements
- `Button` - Buttons with glass variants
- `NeonButton` - Glowing neon-style buttons
- `AnimatedCounter` - Smooth number animations

### Advanced Components
- `SmartAnalytics` - Data visualization with AI insights
- `VirtualizedList` - High-performance lists
- `ParticleField` - Interactive particle effects

## 🎨 Basic Usage

### Glass Card
```tsx
<GlassCard blur="md" opacity={0.1}>
  <p>Your content here</p>
</GlassCard>
```

### Buttons
```tsx
<Button variant="glass" size="lg">
  Glass Button
</Button>

<NeonButton color="blue" glow={true}>
  Neon Button
</NeonButton>
```

### Analytics
```tsx
<SmartAnalytics 
  data={yourData}
  theme="glass"
  showInsights={true}
/>
```

## ⚡ Performance

- **12.3kB** gzipped bundle size
- **Tree-shakeable** - import only what you need
- **Optimized** for React 18+
- **Accessible** WCAG 2.1 compliant

## 🔧 TypeScript Support

Full TypeScript support with IntelliSense:

```tsx
interface MyComponentProps {
  data: AnalyticsData[]
}

const MyComponent: React.FC<MyComponentProps> = ({ data }) => {
  return (
    <SmartAnalytics 
      data={data}
      theme="neural"
      insights="auto"
    />
  )
}
```

## 🎯 Features

- ✨ **Glass Morphism** - Premium frosted glass effects
- 🚀 **High Performance** - Optimized for production
- 📱 **Responsive** - Mobile-first design
- ♿ **Accessible** - WCAG 2.1 AA compliant
- 🎨 **Customizable** - Easy theming system
- 🔧 **TypeScript** - Full type safety

## 📚 Documentation

For detailed documentation and examples, visit our [documentation site](https://docs.temporal.ai/lumina).

## 🤝 Support

- 💬 [GitHub Issues](https://github.com/temporal-ai/lumina-ui/issues)
- 📧 [Email Support](mailto:team@temporal.ai)

## 📄 License

MIT © [Temporal AI Technologies Inc](https://temporal.ai)

---

Built with ❤️ by Temporal AI Technologies
npm package: @nebulaai/monaco-editor
Description: Monaco Editor wrapper with NebulaAI integrations for decentralized development
Author: Jorge Gonzalez & Temporal AI Technologies Inc
Latest version: 1.2.0


# @nebulaai/monaco-editor

A Monaco Editor wrapper with NebulaAI integrations for decentralized development environments.

## Features

- Monaco Editor integration
- Custom NebulaAI themes
- Language providers for enhanced coding experience
- TypeScript support

## Installation

```bash
npm install @nebulaai/monaco-editor
```

## Usage

```typescript
import { MonacoEditor } from '@nebulaai/monaco-editor';

const editor = new MonacoEditor({
  theme: 'nebula-dark',
  language: 'typescript'
});
```

## API Reference

### MonacoEditor

The main editor class that wraps Monaco Editor functionality.

## Contributing

We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Author

Jorge Gonzalez & Temporal AI Technologies Inc
npm package: @nebulaai/name-engine
Description: AI-powered startup name generation engine
Author: NebulaAI
Latest version: 1.0.0

# @nebulaai/name-engine

AI-powered startup name generator with industry intelligence and competitive analysis.

## Features

- 🧠 AI-powered name generation
- 📊 Industry trend analysis  
- 🎯 Competitive intelligence
- 📱 Social media handle checking
- 💯 AI quality scoring
- 🌍 International appeal analysis

## Installation

```bash
npm install @nebulaai/name-engine
```

## Quick Start

```typescript
import { generateNames, analyzeName } from '@nebulaai/name-engine';

// Generate names for AI startups
const results = await generateNames('ai-powered', 4);

results.forEach(result => {
  console.log(`${result.name}: ${result.tagline}`);
  console.log(`AI Score: ${result.aiScore}/100`);
  console.log(`Domain: ${result.domain} (${result.domainStatus})`);
});

// Analyze existing name
const analysis = await analyzeName('DataFlow');
console.log(`Memorability: ${analysis.memorability}%`);
console.log(`Suggestions:`, analysis.suggestions);
```

## API Reference

### `generateNames(vibe, count?, options?)`

Generate startup names for a specific industry.

**Parameters:**
- `vibe` (string): Industry type ('ai-powered', 'fintech', 'saas', etc.)
- `count` (number): Number of names to generate (1-20, default: 4)
- `options` (object): Generation options

**Returns:** `Promise<NebulaaiResult[]>`

### `analyzeName(name)`

Analyze name quality and provide recommendations.

**Parameters:**
- `name` (string): Name to analyze

**Returns:** `Promise<AnalysisResult>`

### `getIndustryTrends(vibe)`

Get industry insights and trends.

**Parameters:**
- `vibe` (string): Industry type

**Returns:** Industry insights object

## Industry Types

- `ai-powered`: AI and machine learning
- `fintech`: Financial technology
- `saas`: Software as a Service
- `web3`: Blockchain and crypto
- `ecommerce`: Online retail
- `social`: Social networking
- `creative`: Creative tools and platforms

## Result Object

```typescript
interface NebulaaiResult {
  id: string;
  name: string;
  tagline: string;
  domain: string;
  domainStatus: 'available' | 'premium' | 'taken';
  vibe: string;
  aiScore: number;              // AI quality score (0-100)
  memorabilityScore: number;    // How memorable (0-100)
  brandingPotential: number;    // Branding potential (0-100)
  internationalAppeal: number;  // International appeal (0-100)
  industryInsights: {
    trendScore: number;
    marketCap: string;
    growthRate: string;
    aiRecommendation: string;
  };
  competitiveAnalysis: {
    similarNames: string[];
    differentiationScore: number;
    marketPositioning: string;
  };
  socialMediaHandles: Array<{
    platform: string;
    handle: string;
    available: boolean;
  }>;
}
```

## Error Handling

```typescript
import { ValidationError } from '@nebulaai/core';

try {
  const results = await generateNames('invalid-vibe', 4);
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Invalid input:', error.message);
  }
}
```

## License

MIT
npm package: @nebulaai/react-hooks
Description: Collection of React hooks for NebulaAI applications and decentralized development
Author: Jorge Gonzalez & Temporal AI Technologies Inc
Latest version: 1.1.0


# @nebulaai/react-hooks

Collection of React hooks for NebulaAI applications and decentralized development workflows.

## Features

- Custom React hooks for NebulaAI integration
- TypeScript support
- Optimized for performance
- Easy to use and extend

## Installation

```bash
npm install @nebulaai/react-hooks
```

## Usage

```typescript
import { useNebulaAI } from '@nebulaai/react-hooks';

function MyComponent() {
  const { data, loading, error } = useNebulaAI();
  
  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
  
  return <div>Data: {JSON.stringify(data)}</div>;
}
```

## Available Hooks

- `useNebulaAI` - Main NebulaAI integration hook
- `useProject` - Project management hook
- `useCollaboration` - Real-time collaboration hook

## Contributing

We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Author

Jorge Gonzalez & Temporal AI Technologies Inc
npm package: @nebulaai/react-query
Description: React Query integration for NebulaAI applications with optimized data fetching
Author: Jorge Gonzalez & Temporal AI Technologies Inc
Latest version: 1.0.0


# @nebulaai/react-query

React Query integration for NebulaAI applications with optimized data fetching and caching.

## Features

- Pre-configured React Query setup for NebulaAI
- Optimized queries for decentralized development
- TypeScript support
- Built-in error handling and retry logic

## Installation

```bash
npm install @nebulaai/react-query
```

## Usage

```typescript
import { NebulaAIQueryProvider, useNebulaAIQuery } from '@nebulaai/react-query';

function App() {
  return (
    <NebulaAIQueryProvider>
      <MyComponent />
    </NebulaAIQueryProvider>
  );
}

function MyComponent() {
  const { data, isLoading, error } = useNebulaAIQuery('projects');
  
  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error loading projects</div>;
  
  return <div>Projects: {data.length}</div>;
}
```

## API Reference

### NebulaAIQueryProvider

Provider component that sets up React Query for NebulaAI.

### useNebulaAIQuery

Hook for querying NebulaAI data with built-in optimizations.

## Contributing

We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Author

Jorge Gonzalez & Temporal AI Technologies Inc
npm package: @nebulaai/terminal-core
Description: Core terminal functionality for NebulaAI development environments
Author: Jorge Gonzalez & Temporal AI Technologies Inc
Latest version: 1.0.0


# @nebulaai/terminal-core

Core terminal functionality for NebulaAI development environments with xterm.js integration.

## Features

- Terminal emulation with xterm.js
- Custom themes and addons
- WebSocket support for remote terminals
- Command processing utilities
- TypeScript support

## Installation

```bash
npm install @nebulaai/terminal-core
```

## Usage

```typescript
import { NebulaTerminal } from '@nebulaai/terminal-core';

const terminal = new NebulaTerminal({
  theme: 'nebula-dark',
  fontSize: 14
});

terminal.open(document.getElementById('terminal-container'));
```

## API Reference

### NebulaTerminal

Main terminal class that wraps xterm.js functionality.

### TerminalTheme

Theme configuration for terminal appearance.

## Contributing

We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

## License

MIT License - see [LICENSE](LICENSE) file for details.

## Author

Jorge Gonzalez & Temporal AI Technologies Inc
npm package: @nebulae/event-store-tpi-rx6
Description: Event Store Lib for NebulaE Microservices
Author: sebastian.molano@nebulae.com.co
Latest version: 1.2.0

# Event Store


# Installation

Assuming that Node.js is already installed & running, 

## Install as dependency
```sh
$ npm install @nebulae/event-store-tpi-rx6
```

# usage
## Author & Contributors

Developed &amp; maintained by authors: <b>Sebastian Molano & Esteban Zapata on behalf of Nebula Engineering SAS</b><br>
Follow Nebula Engineering at: <a href="https://github.com/NebulaEngineering" target="_blank">github</a>

## License

The MIT License (MIT)

Copyright (c) 2018 Nebula Engineering SAS