open-index/open-npm huggingface dataset:
npm package: @ortelius/create-ortelius-react-app
Description: A wrapper around create-react-app which adds packages and a basic boilerplate for your different inorigo web application projects. Helps you get up and running quickly.
Author: Henrik Olofsson
Latest version: 2.0.3

# create-ortelius-react-app
A create-react-app wrapper for Ortelius applications. This script will run create-react-app and produce a code boilerplate for Inorigo projects. It will NOT eject your project.

### Using
Browse to your prefered projects folder and use the following command
```
npx @ortelius/create-ortelius-react-app my-app-name
```

This will produce a new boilerplate project.
npm package: @ortelius/inorigojs
Description: Inorigo API Utility
Author: Ortelius AB
Latest version: 22.2.3

# InorigoJS

<div align="center">
  <img src="https://www.ortelius.com/wp-content/uploads/2020/05/Ortelius-logo-black.png" />
  <br>
  InorigoJS is the only Inorigo utility you need! Built and supported by Ortelius.
  <br>
  <a target="_blank" href="https://orteliusab.github.io/inorigojs/docs/dist/">Documentation</a>
</div>

# Contribute

Are you missing something? Consider contributing your time to the project! You can of course also post suggestions, bug reports or general questions to us here on Github.
npm package: @ortelius/virrvarr
Description: An awesome network graph 
Author: Ortelius AB
Latest version: 0.1.59

# virrvarr

<div align="center">
  <img src="https://img.shields.io/github/license/orteliusab/virrvarr" style="display:inline-block;">
  <img src="https://img.shields.io/npm/v/@ortelius/virrvarr?color=1" style="display:inline-block;">
  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square" style="display:inline-block;">
  <br>
  <br>
  <br>
  <img src="https://www.ortelius.com/wp-content/uploads/2020/05/Ortelius-logo-black.png"/>
  <br>
  Virrvarr is an awesome network graph built and supported by Ortelius.
  <br>
  <a target="_blank" href="https://orteliusab.github.io/virrvarr/bundle/example">Demo</a> | <a target="_blank" href="https://orteliusab.github.io/virrvarr/docs/dist/index.html">Documentation</a>
</div>

# Contribute

Are you missing something? Consider contributing your time to the project! You can of course also post suggestions, bug reports or general questions to us here on Github.

## For developers

To install:

```bash
npm install
```

To start the development server:

```bash
npm start
```

To build the component bundle:

```bash
npm run build
```

## Screenshots

![Screenshot 1](/ss1.PNG?raw=true)
npm package: @ortense/consolestyle
Description: ![consolestyle demo in vscode terminal](https://raw.githubusercontent.com/ortense/consolestylejs/main/media/banner.png)
Author: Marcus Ortense
Latest version: 1.1.0

# @ortense/consolestyle

![consolestyle demo in vscode terminal](https://raw.githubusercontent.com/ortense/consolestylejs/main/media/banner.png)

[![Coverage Status](https://coveralls.io/repos/github/ortense/consolestylejs/badge.svg?branch=main)](https://coveralls.io/github/ortense/consolestylejs?branch=main) ![npm bundle size](https://img.shields.io/bundlephobia/min/%40ortense%2Fconsolestyle) [![GitHub License](https://img.shields.io/github/license/mashape/apistatus?branch=main&label=License&logo=GitHub&logoColor=ffffff&labelColor=282828&color=informational&style=flat)](https://github.com/ortense/consolestylejs/blob/main/LICENSE)


A lightweight package weighing just 18.8 kB that allows you to style your console output with ease, adding colors, backgrounds, and various text styles to enhance your command-line experience.


## Install

Pick your favorite package manager.

```sh
npm install @ortense/consolestyle  # npm
yarn add  @ortense/consolestyle    # yarn
pnpm add @ortense/consolestyle     # pnpm
bun add @ortense/consolestyle      # bun
deno add @ortense/consolestyle     # deno from jsr.io
```

## Usage

You can use the fluent api of `style` function.

```ts
import {style} from '@ortense/consolestyle'

const message = style('Hello there! 👋').cyan().italic()
  .emptyLine()
  .newLine('Are u tired of boring console outputs?').inverse()
  .emptyLine()
  .newLine('✨ Now u can easily create fun console messages! 🦄').magenta().bold()

console.log(message.toString())
```

Alternatively, you can choose specific functions to apply styles to your console output.

```ts
import {green, underline} from '@ortense/consolestyle'

const message = underline(green('Simplicity is sophistication 🍃'))

console.log(message)
```
More details in the [complete documentation](https://ortense.github.io/consolestylejs/).

## Key Features

- Easily style your console output with a fluent API.
- Apply a wide range of text colors, backgrounds, and styles.
- Enhance your command-line interface with vibrant and visually appealing messages.

### Available styles

- `red()`: Apply red text color.
- `green()`: Apply green text color.
- `yellow()`: Apply yellow text color.
- `blue()`: Apply blue text color.
- `magenta()`: Apply magenta text color.
- `cyan()`: Apply cyan text color.
- `bgRed()`: Apply red background color.
- `bgGreen()`: Apply green background color.
- `bgYellow()`: Apply yellow background color.
- `bgBlue()`: Apply blue background color.
- `bgMagenta()`: Apply magenta background color.
- `bgCyan()`: Apply cyan background color.
- `inverse()`: Apply inverted colors
- `bold()`: Apply bold text style.
- `dim()`: Apply dim text style.
- `italic()`: Apply italic text style.
- `underline()`: Apply underline text style.
- `strike()`: Apply strike-through text style.


## License

This package is licensed under the MIT License. See the LICENSE file for details.
npm package: @ortfo/db
Description: ortfodb client library
Author: Ewen Le Bihan
Latest version: 1.6.1

# @ortfo/db

A [ortfodb](https://github.com/ortfo/db) client library for Javascript (and Typescript).

Generated from [ortfo's JSON schemas](https://github.com/ortfo/db/tree/main/schemas) thanks to [Quicktype](https://quicktype.io)
npm package: @orth/sdk
Description: TypeScript SDK to call any API on the Orthogonal platform
Author: Orthogonal
Latest version: 0.3.1

# @orth/sdk

TypeScript SDK to call any API on the Orthogonal platform.

## Installation

```bash
npm install @orth/sdk
```

## Quick Start

```typescript
import Orthogonal from "@orth/sdk";

const orthogonal = new Orthogonal({
  apiKey: process.env.ORTHOGONAL_API_KEY,
});

const response = await orthogonal.run({
  api: "andi",
  path: "/api/v1/search",
  query: { q: "what is the weather today" },
});

console.log(response.data);
console.log(response.price); // e.g., "0.01"
```

## Response

### Success

```json
{
  "success": true,
  "price": "0.01",
  "data": { ... }
}
```

### Error

```json
{
  "success": false,
  "price": "0",
  "error": "API my-api not found or not active"
}
```

## License

MIT
npm package: @ortha/admin-home
Description: Home/dashboard UI plugin — provides the root authenticated layout and landing page for the Ortha admin application. This is a foundational plugin that most feature plugins depend on.
Latest version: 0.0.4

# @ortha/admin-home

Home/dashboard UI plugin — provides the root authenticated layout and landing page for the Ortha admin application. This is a foundational plugin that most feature plugins depend on.

## Installation

Internal monorepo dependency — import directly:

```ts
import { homePlugin } from '@ortha/admin-home';
```

## Usage

### Registering the plugin

```ts
import { bootstrap } from '@ortha/admin-platform-bootstrap';
import { homePlugin } from '@ortha/admin-home';

bootstrap(document.getElementById('root')!, [
    homePlugin()
    // ...other plugins that depend on 'home'
]);
```

### Depending on the home plugin

Other feature plugins declare a dependency to use the home layout as their parent route:

```ts
const myPlugin = (): AdminPlugin =>
    Object.freeze({
        id: 'my-feature',
        name: 'My Feature',
        dependencies: ['home'],
        setup(ctx) {
            ctx.router.addRoute({
                path: '/my-feature',
                component: MyFeaturePage
            });
        }
    });
```

## Routes

| Path | Page                    | Description                   |
| ---- | ----------------------- | ----------------------------- |
| `/`  | Root layout + dashboard | Wraps all authenticated pages |

## API Reference

| Export         | Kind    | Description                                |
| -------------- | ------- | ------------------------------------------ |
| `homePlugin()` | factory | Admin plugin — registers root layout route |

## Layout Structure

The home layout provides:

- **Top navigation bar** — renders `SlotRenderer` for `SLOT_TOPBAR_NAV_MAIN_ACTIONS`
- **Sidebar** — application navigation
- **Content area** — renders child routes via `<Outlet />`

## Internal Structure

```
src/lib/
└── homePlugin/index.ts    # Plugin factory with layout route registration
```

## Key Patterns

- This is a foundational plugin — most feature plugins declare `dependencies: ['home']`.
- The layout renders `SlotRenderer` for `SLOT_TOPBAR_NAV_MAIN_ACTIONS` from `@ortha/admin-platform-core`.
- No external API calls — purely layout and navigation infrastructure.

## Dependencies

- `@ortha/admin-platform-core` — `SlotRenderer`, `SLOT_TOPBAR_NAV_MAIN_ACTIONS`, `ProtectedRoute`
- `@ortha/admin-platform-plugin-registry` — plugin types
- `@ortha/design-system` — theme and UI components

## Building

```bash
nx build admin-home
```
npm package: @ortha/admin-platform-bootstrap
Description: Thin orchestrator that wires the plugin-registry services together and mounts the React application. This is the entry point for bootstrapping the entire Ortha admin CMS.
Latest version: 0.0.4

# @ortha/admin-platform-bootstrap

Thin orchestrator that wires the plugin-registry services together and mounts the React application. This is the entry point for bootstrapping the entire Ortha admin CMS.

## Installation

Internal monorepo dependency — import directly:

```ts
import { bootstrap } from '@ortha/admin-platform-bootstrap';
```

## Usage

```ts
import { bootstrap } from '@ortha/admin-platform-bootstrap';
import { identityPlugin } from '@ortha/admin-identity';
import { homePlugin } from '@ortha/admin-home';
import { projectsPlugin } from '@ortha/admin-projects';
import { usersPlugin } from '@ortha/admin-users';

bootstrap(document.getElementById('root')!, [
    identityPlugin(),
    homePlugin(),
    projectsPlugin(),
    usersPlugin()
]);
```

> **Note:** `CorePlugin` is auto-prepended — never include it manually.

## Bootstrap Lifecycle

```
bootstrap(mountElement, plugins, config?)
```

1. **Prepend CorePlugin** — always first; consumers must never include it.
2. **Validate** — checks required fields, duplicate IDs, and resolvable dependencies.
3. **Topological sort** — resolves `setup()` call order via Kahn's algorithm.
4. **Instantiate services** — creates fresh `routerService()`, `slotService()`.
5. **Register plugins** — populates `pluginRegistry()` in sorted order.
6. **Call `setup()`** — iterates sequentially, `await`ing each plugin.
7. **Mount React** — renders `<CoreApp>` wrapped in `RouterServiceContext` and `SlotServiceContext` providers.

## API Reference

| Export        | Kind     | Description                                 |
| ------------- | -------- | ------------------------------------------- |
| `bootstrap()` | function | Initialises and mounts the entire admin CMS |

### Parameters

| Parameter      | Type            | Description                              |
| -------------- | --------------- | ---------------------------------------- |
| `mountElement` | `HTMLElement`   | DOM element to mount React into          |
| `plugins`      | `AdminPlugin[]` | Array of plugin factory results          |
| `config`       | `AdminConfig?`  | Optional configuration (basePath, debug) |

## Internal Structure

```
src/lib/
└── bootstrap/index.ts    # The entire bootstrap function
```

## Dependencies

- `@ortha/admin-platform-core` — `CorePlugin`, `CoreApp`, context providers
- `@ortha/admin-platform-plugin-registry` — plugin types, services, validation, sort

## Key Patterns

- Keep this package as a pure wiring layer — do not add business logic here.
- The bootstrap function is `async` to support asynchronous plugin `setup()` calls.
- Services are created fresh on every bootstrap call — no singletons.

## Building

```bash
nx build admin-platform-bootstrap
```
npm package: @ortha/api-docs
Description: Fastify plugin for API documentation — generates OpenAPI/Swagger specs from route schemas and serves an interactive documentation UI via Scalar.
Latest version: 0.0.4

# @ortha/api-docs

Fastify plugin for API documentation — generates OpenAPI/Swagger specs from route schemas and serves an interactive documentation UI via Scalar.

## Installation

Internal monorepo dependency — import directly:

```ts
import { apiDocsPlugin } from '@ortha/api-docs';
import type { DocsConfig } from '@ortha/api-docs';
```

## Usage

### Registering the plugin

```ts
import { bootstrap } from '@ortha/server-platform-bootstrap';
import { apiDocsPlugin } from '@ortha/api-docs';

await bootstrap({
    config: bootstrapConfig,
    plugins: [
        // Register BEFORE domain plugins to capture all routes
        apiDocsPlugin({
            title: 'Ortha API',
            version: '1.0.0',
            description: 'Ortha CMS API documentation'
        })
        // ...domain plugins
    ]
});
```

> **Important:** The docs plugin must be registered **before** domain plugins so it can capture all route schemas for the OpenAPI spec.

### Accessing the documentation

Once the server is running, the interactive API documentation is available at:

```
http://localhost:4000/docs
```

## API Reference

| Export            | Kind    | Description                                    |
| ----------------- | ------- | ---------------------------------------------- |
| `apiDocsPlugin()` | factory | Fastify plugin — registers Swagger + Scalar UI |
| `DocsConfig`      | type    | Configuration for docs (title, version, etc.)  |

### DocsConfig

| Property      | Type     | Description             |
| ------------- | -------- | ----------------------- |
| `title`       | `string` | API documentation title |
| `version`     | `string` | API version string      |
| `description` | `string` | API description text    |

## Internal Structure

```
src/lib/
├── types/index.ts              # DocsConfig type
└── apiDocsPlugin/index.ts      # Fastify plugin factory (fp wrapper)
```

## Dependencies

- `@fastify/swagger` — OpenAPI spec generation from route schemas
- `@scalar/fastify-api-reference` — Interactive API documentation UI at `/docs`

## Key Patterns

- The plugin uses `fastify-plugin` (`fp`) wrapper to share the Swagger decorator across the Fastify instance.
- Route schemas (JSON Schema) defined in domain plugins are automatically picked up for the OpenAPI spec.
- Scalar provides a modern, interactive UI alternative to Swagger UI.

## Building

```bash
nx build api-docs
```
npm package: @ortha/server-platform-bootstrap
Description: Creates, configures, and starts a Fastify server instance. Registers all provided plugins sequentially before binding the port. This is the entry point for the Ortha server application.
Latest version: 0.0.4

# @ortha/server-platform-bootstrap

Creates, configures, and starts a Fastify server instance. Registers all provided plugins sequentially before binding the port. This is the entry point for the Ortha server application.

## Installation

Internal monorepo dependency — import directly:

```ts
import { bootstrap } from '@ortha/server-platform-bootstrap';
import type {
    BootstrapConfig,
    ServerPlugin
} from '@ortha/server-platform-bootstrap';
```

## Usage

```ts
import { bootstrap } from '@ortha/server-platform-bootstrap';
import { databasePlugin } from '@ortha/server-platform-database';
import { identityServerPlugin } from '@ortha/server-identity';
import { projectsServerPlugin } from '@ortha/server-projects';

await bootstrap({
    config: {
        host: '0.0.0.0',
        port: 4000,
        logLevel: 'info'
    },
    plugins: [
        databasePlugin({ ...dbConfig, schemas: [identitySchema] }),
        identityServerPlugin(jwtConfig),
        projectsServerPlugin()
    ]
});
```

## Bootstrap Flow

```
bootstrap({ config, plugins? })
```

1. **Create Fastify** — instance with Pino logger and querystring parser.
2. **Set error handler** — global error handler using `buildErrorResponse()` from `@ortha/server-utils`.
3. **Register sensible** — `@fastify/sensible` for HTTP error helpers.
4. **Register plugins** — all provided plugins registered sequentially.
5. **Listen** — call `app.listen()` with configured host and port.

## API Reference

| Export            | Kind     | Description                                          |
| ----------------- | -------- | ---------------------------------------------------- |
| `bootstrap()`     | function | Creates Fastify, registers plugins, starts listening |
| `BootstrapConfig` | type     | Server config — `logLevel`, `host`, `port`           |
| `ServerPlugin`    | type     | Alias for `FastifyPluginAsync`                       |

### BootstrapConfig

| Property   | Type     | Description                                |
| ---------- | -------- | ------------------------------------------ |
| `host`     | `string` | Server bind address (e.g. `'0.0.0.0'`)     |
| `port`     | `number` | Server bind port (e.g. `4000`)             |
| `logLevel` | `string` | Pino log level (`'info'`, `'debug'`, etc.) |

## Internal Structure

```
src/lib/
├── types/index.ts      # BootstrapConfig, ServerPlugin types
└── bootstrap.ts        # Bootstrap function
```

## Dependencies

- `@ortha/server-utils` — error response builder
- `@fastify/sensible` — HTTP error helpers

## Building

```bash
nx build server-platform-bootstrap
```
npm package: @ortha/server-platform-env
Description: Typed environment variable parsers with validation. Provides a set of helper functions to read, parse, and validate environment variables with type safety and sensible defaults.
Latest version: 0.0.4

# @ortha/server-platform-env

Typed environment variable parsers with validation. Provides a set of helper functions to read, parse, and validate environment variables with type safety and sensible defaults.

## Installation

Internal monorepo dependency — import directly:

```ts
import {
    envString,
    envInt,
    envBool,
    envPort,
    envEnum
} from '@ortha/server-platform-env';
```

## Usage

```ts
import {
    envString,
    envInt,
    envBool,
    envPort,
    envEnum
} from '@ortha/server-platform-env';

const config = {
    host: envString('HOST', '0.0.0.0'),
    port: envPort('PORT', 3000),
    logLevel: envEnum('LOG_LEVEL', ['info', 'debug', 'warn', 'error'], 'info'),
    dbHost: envString('DB_HOST', 'localhost'),
    dbPort: envInt('DB_PORT', 5432),
    dbLogging: envBool('DB_LOGGING', false)
};
```

## API Reference

| Export        | Kind     | Description                                                   |
| ------------- | -------- | ------------------------------------------------------------- |
| `envString()` | function | Read string env var — required if no default provided         |
| `envInt()`    | function | Read and parse integer env var — throws on non-numeric values |
| `envBool()`   | function | Read boolean env var — accepts `"true"` / `"false"` strings   |
| `envPort()`   | function | Read port number with range validation (1–65535)              |
| `envEnum()`   | function | Read env var constrained to an allowed set of values          |

### Function Signatures

```ts
envString(name: string, defaultValue?: string): string;
envInt(name: string, defaultValue?: number): number;
envBool(name: string, defaultValue?: boolean): boolean;
envPort(name: string, defaultValue?: number): number;
envEnum<T extends string>(name: string, allowed: T[], defaultValue?: T): T;
```

All functions throw if the environment variable is missing and no default is provided.

## Internal Structure

```
src/lib/
└── env/index.ts    # All env helper functions
```

## Building

```bash
nx build server-platform-env
```