open-index/open-npm huggingface dataset:
npm package: @flicmd/bytemd-plugin-frontmatter
Description: ByteMD plugin to parse frontmatter
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-frontmatter

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-frontmatter.svg)](https://npm.im/@flicmd/bytemd-plugin-frontmatter)

ByteMD plugin to parse frontmatter

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import frontmatter from '@flicmd/bytemd-plugin-frontmatter'

new Editor({
  target: document.body,
  props: {
    plugins: [
      frontmatter(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-gemoji
Description: ByteMD plugin to support Gemoji shortcodes
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-gemoji

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-gemoji.svg)](https://npm.im/@flicmd/bytemd-plugin-gemoji)

ByteMD plugin to support Gemoji shortcodes

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import gemoji from '@flicmd/bytemd-plugin-gemoji'

new Editor({
  target: document.body,
  props: {
    plugins: [
      gemoji(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-highlight
Description: ByteMD plugin to highlight code blocks
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-highlight

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-highlight.svg)](https://npm.im/@flicmd/bytemd-plugin-highlight)

ByteMD plugin to highlight code blocks

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import highlight from '@flicmd/bytemd-plugin-highlight'
import 'highlight.js/styles/default.css'

new Editor({
  target: document.body,
  props: {
    plugins: [
      highlight(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-highlight-ssr
Description: ByteMD plugin to highlight code blocks (SSR compatible)
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-highlight-ssr

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-highlight-ssr.svg)](https://npm.im/@flicmd/bytemd-plugin-highlight-ssr)

ByteMD plugin to highlight code blocks (SSR compatible)

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import highlight from '@flicmd/bytemd-plugin-highlight-ssr'
import 'highlight.js/styles/default.css'

new Editor({
  target: document.body,
  props: {
    plugins: [
      highlight(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-math
Description: ByteMD plugin to support math formula
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-math

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-math.svg)](https://npm.im/@flicmd/bytemd-plugin-math)

ByteMD plugin to support math formula

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import math from '@flicmd/bytemd-plugin-math'
import 'katex/dist/katex.css'

new Editor({
  target: document.body,
  props: {
    plugins: [
      math(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-medium-zoom
Description: ByteMD plugin to zoom images like Medium
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-medium-zoom

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-medium-zoom.svg)](https://npm.im/@flicmd/bytemd-plugin-medium-zoom)

ByteMD plugin to zoom images like Medium

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import mediumZoom from '@flicmd/bytemd-plugin-medium-zoom'

new Editor({
  target: document.body,
  props: {
    plugins: [
      mediumZoom(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @flicmd/bytemd-plugin-mermaid
Description: ByteMD plugin to support Mermaid diagram
Author: Rongjian Zhang
Latest version: 1.21.4

# @flicmd/bytemd-plugin-mermaid

[![npm](https://img.shields.io/npm/v/@flicmd/bytemd-plugin-mermaid.svg)](https://npm.im/@flicmd/bytemd-plugin-mermaid)

ByteMD plugin to support Mermaid diagram

## Usage

```js
import { Editor } from '@flicmd/bytemd'
import mermaid from '@flicmd/bytemd-plugin-mermaid'

new Editor({
  target: document.body,
  props: {
    plugins: [
      mermaid(),
      // ... other plugins
    ],
  },
})
```

## License

MIT
npm package: @fliege01/purpleberry
Description: # Installation
Latest version: 1.1.0

# Introduction

# Installation

```shell
npm install --save @fliege01/purpleberry
yarn install @fliege01/purpleberry
```

# Examples

```typescript
import PermissionManager from '@fliege01/purpleberry';

const myRoleSchema = {
    $version: 1,
    statements: [
        {
            "action": "some.action",
            "resource": "*"
        },
        {
            "action": "another.action:any",
            "resource": "a.special.resource"
        }
    ]
}

const PM = new PermissionManager();
PM.addRoleSchema('myRole', myRoleSchema);

const roleCtx = PM.createRoleContext('myRole');

roleCtx.can('some.action', 'some.resource', true); // returns true
roleCtx.can('some.action', 'some.resource', false); // returns false since is not owner

roleCtx.can('another.action', 'another.resource', false); // returns false
roleCtx.can('another.action', 'a.special.resource', false); // returns true 

```
## Policies
PurpleBerry uses role and permission policies to manage single statements of the application. 
A role can reference to other roles and permission policies. Permission policies can only reference to other permission policies.

### Simple dependency schema
```text
   Permission
    /    \
Role   Permission
    \  /
   Role  --  Permission
```
## Ownerships

Each action can points to ressources which are owned or not. If no further informations provided, PurpleBerry will work as the action only matches to owned ressources.

If you want the action to also apply to not owned ressources you need to add a `:any` at the end of te action definition. `posts.*:any` or `user.updatePassword:any`

The ownerships are not handled by PurpleBerry. To determine if the ressource is owned you need to pass the boolean parameter to the `.can(string, string[, boolean])` function
## Statements
A statement is a combination of one or multiple actions AND one or multiple resources. The permission is granted if both elements hits inside one single statement. Role and permission policies can store multiple statements.

```json
{
    "action": [
        "updateProfile"
    ],
    "resource": [
        "profile.*"
    ]
}
```
npm package: @fliegwerk/dir-tree
Description: Recursively parses a directory and returns the content as an object
Author: fliegwerk
Latest version: 1.0.0

# `@fliegwerk/dir-tree`

![NPM](https://img.shields.io/npm/l/@fliegwerk/dir-tree)
![npm (scoped)](https://img.shields.io/npm/v/@fliegwerk/dir-tree)
![node-current (scoped)](https://img.shields.io/node/v/@fliegwerk/dir-tree)
![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/npm/@fliegwerk/dir-tree)
![GitHub Repo stars](https://img.shields.io/github/stars/fliegwerk/dir-tree?style=social)

Recursively parses a directory and returns the content as an object

## Installation

```shell
npm install @fliegwerk/dir-tree
```

or

```shell
yarn add @fliegwerk/dir-tree
```

## Usage

```js
const dirTree = require('@fliegwerk/dir-tree');
const {join} = require('path');

const tree = await dirTree(
    join(__dirname, 'template')
);

console.log(tree.type); // 'file' | 'directory' | 'link' | 'unreadable'
console.log(tree);
```

`dirTree(path)` returns a `Promise` that resolves to a `TreeElement` object.

A `TreeElement` object can be one of four types:

- `FileElement` (`element.type === 'file'`) - a simple file in the file system
- `DirectoryElement` (`element.type === 'directory'`) - a directory containing `children: TreeElement[]`
- `LinkElement` (`element.type === 'link'`) - a type representing a symlink in the file system. Contains
  a `destination: string` that is the link's destination path
- `UnreadableElement` (`element.type === 'unreadable'`) - a type representing an unreadable file in the file system.
  Contains an `error: unknown` that is the error that got thrown while trying to read the file.

Apart from these additional properties, all `TreeElement` objects have the following properties:

- `type: 'file' | 'directory' | 'link' | 'unreadable'` - the element type
- `path: string` - the full, absolute path to the element
- `ext: string` - the file name extension (including the period), if it exists. Empty string (`''`) if no file extension
  exists.
- `name: string` - the name of the file (including the extension)

## Additional options

No additional options exist in this library. We want to focus on doing one job well (and rock-solid). That's why we don'
t provide a lot of options around our core functionality.
npm package: @fliegwerk/logsemts
Description: A semantic logging solution implemented with TypeScript
Author: fliegwerk
Latest version: 0.4.3

<p align="center">
<img alt="LogSemTS Logo" height="300" src="assets/logo.png" />
</p>

# @fliegwerk/logsemts - A modular, semantic logger written in TypeScript

[npm package](https://npmjs.com/package/@fliegwerk/logsemts)
| [Library Documentation](https://fliegwerk.github.io/logsemts)

![CI](https://github.com/fliegwerk/logsemts/workflows/CI/badge.svg)
![ShiftLeft Scan](https://github.com/fliegwerk/logsemts/workflows/ShiftLeft%20Scan/badge.svg)
![CodeQL](https://github.com/fliegwerk/logsemts/workflows/CodeQL/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/fliegwerk/logsemts/badge.svg?branch=master)](https://coveralls.io/github/fliegwerk/logsemts?branch=master)
[![Maintainability](https://api.codeclimate.com/v1/badges/c2d8d3ab896d0bb100ea/maintainability)](https://codeclimate.com/github/fliegwerk/logsemts/maintainability)
[![Rate on Openbase](https://badges.openbase.io/js/rating/@fliegwerk/logsemts.svg)](https://openbase.io/js/@fliegwerk/logsemts?utm_source=embedded&utm_medium=badge&utm_campaign=rate-badge)

A modular, color-coded, TypeScript-based semantic logger that can be used in NodeJS, the browser and in many other scenarios.

## Example

```ts
// Import the logger:
import Logger, { BrowserLogger } from '@fliegwerk/logsemts';

// Create a new logger
const logger = new Logger({
	loggers: [BrowserLogger()] // that exclusively outputs to the browser dev tools
});

// get a new subsystem logger for the API Client
const apiClientLogger = logger.getComponentLogger('API Client');

// log a success message
apiClientLogger.success('Data fetched successfully');
```

## Installation

```shell script
$ npm install @fliegwerk/logsemts
```

or

```shell script
$ yarn add @fliegwerk/logsemts
```

## Concept

![Concept Overview Diagram](assets/drawio/concept-overview.png)

There are three primary components in logsemts:

- _Component Loggers_: Logger objects for specific subsystems (for example, an API connector and a login form).
  These objects contain functions like `.log()`, `.debug()`, `.warn()`, etc. to log messages regarding this subsystem.
- _Log Functions_: Functions that log a message to a specific target. Targets could be the Browser's Developer tools, a
  Database and an API.
- _Core_: The library's core consists of the `Logger` class. Usually, only one instance of that class gets used in an
  application. It manages the different components (_Component Loggers_ get created using the
  `logger.getComponentLogger(name)` function) and _Log Functions_. It also forwards the messages from the _Component
  Loggers_ to the registered _Log Functions_.
npm package: @flies-ui/flelte-g6
Description: Everything you need to build a Svelte project, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/master/packages/create-svelte).
Latest version: 0.1.7

# create-svelte

Everything you need to build a Svelte project, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/master/packages/create-svelte).

## Creating a project

If you're seeing this, you've probably already done this step. Congrats!

```bash
# create a new project in the current directory
npm create svelte@latest

# create a new project in my-app
npm create svelte@latest my-app
```

## Developing

Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:

```bash
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

## Building

To create a production version of your app:

```bash
npm run build
```

You can preview the production build with `npm run preview`.

> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
npm package: @flight-framework/adapter-aws
Description: AWS adapter for Flight Framework - deploy to Lambda, Amplify, or API Gateway
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-aws

# @flight-framework/adapter-aws

AWS Lambda deployment adapter for Flight Framework. Deploy to Lambda with API Gateway or Lambda URLs.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Deployment Options](#deployment-options)
- [Build Output](#build-output)
- [Deployment](#deployment)
- [License](#license)

---

## Installation

```bash
npm install @flight-framework/adapter-aws
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import aws from '@flight-framework/adapter-aws';

export default defineConfig({
    adapter: aws(),
});
```

---

## Configuration

```typescript
aws({
    // Lambda runtime
    runtime: 'nodejs20.x',
    
    // Memory allocation (MB)
    memory: 512,
    
    // Timeout (seconds)
    timeout: 30,
    
    // Architecture
    architecture: 'arm64',  // or 'x86_64'
    
    // Region
    region: 'us-east-1',
    
    // Use Lambda URLs (simpler, no API Gateway)
    lambdaUrl: true,
    
    // Streaming responses
    streaming: true,
});
```

---

## Deployment Options

### Lambda Function URLs

Simplest option, no API Gateway needed:

```typescript
aws({
    lambdaUrl: true,
});
```

### API Gateway HTTP API

For custom domains and API features:

```typescript
aws({
    apiGateway: 'http',  // HTTP API (v2)
});
```

### API Gateway REST API

Full control with request/response transformations:

```typescript
aws({
    apiGateway: 'rest',  // REST API (v1)
});
```

---

## Build Output

```
.aws/
├── lambda/
│   ├── index.mjs        # Lambda handler
│   └── chunks/          # Code-split chunks
├── static/              # S3 static assets
└── template.yaml        # SAM template (optional)
```

---

## Deployment

### AWS SAM

```bash
# Install SAM CLI
brew install aws-sam-cli

# Build
npm run build

# Deploy
sam deploy --guided
```

### SST (Recommended)

```typescript
// sst.config.ts
export default {
    config() {
        return { name: 'my-flight-app', region: 'us-east-1' };
    },
    stacks(app) {
        app.stack(({ stack }) => {
            const site = new SsrSite(stack, 'Site', {
                path: '.',
            });
            stack.addOutputs({ URL: site.url });
        });
    },
};
```

### Terraform

```hcl
resource "aws_lambda_function" "app" {
  filename         = ".aws/lambda.zip"
  function_name    = "my-flight-app"
  role             = aws_iam_role.lambda.arn
  handler          = "index.handler"
  runtime          = "nodejs20.x"
  memory_size      = 512
  timeout          = 30
}
```

---

## License

MIT
npm package: @flight-framework/adapter-bun
Description: Bun adapter for Flight Framework - ultra-fast Bun runtime
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-bun

# @flight-framework/adapter-bun

Bun runtime deployment adapter for Flight Framework. Ultra-fast builds and runtime performance.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Build Output](#build-output)
- [Running in Production](#running-in-production)
- [Docker](#docker)
- [License](#license)

---

## Installation

```bash
bun add @flight-framework/adapter-bun
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import bun from '@flight-framework/adapter-bun';

export default defineConfig({
    adapter: bun(),
});
```

Build and run:

```bash
bun run build
bun .output/server/index.ts
```

---

## Configuration

```typescript
bun({
    // Host to bind
    host: '0.0.0.0',
    
    // Port to listen on
    port: 3000,
    
    // Enable compression
    compression: true,
    
    // Development mode features
    development: process.env.NODE_ENV !== 'production',
});
```

---

## Build Output

```
.output/
├── server/
│   ├── index.ts         # Server entry (Bun-native)
│   └── chunks/          # Code-split chunks
└── client/
    └── assets/          # Static files
```

---

## Running in Production

```bash
# Build
bun run build

# Start
bun .output/server/index.ts

# With environment variables
PORT=8080 bun .output/server/index.ts
```

---

## Docker

```dockerfile
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build

FROM oven/bun:1-slim
WORKDIR /app
COPY --from=builder /app/.output .output
EXPOSE 3000
CMD ["bun", ".output/server/index.ts"]
```

---

## License

MIT
npm package: @flight-framework/adapter-deno
Description: Deno adapter for Flight Framework - deploy to Deno Deploy or self-host with Deno
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-deno

# @flight-framework/adapter-deno

Deno Deploy adapter for Flight Framework. Deploy to Deno's global edge network.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Deno Deploy](#deno-deploy)
- [Build Output](#build-output)
- [License](#license)

---

## Installation

```bash
deno add @flight-framework/adapter-deno
# or with npm
npm install @flight-framework/adapter-deno
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import deno from '@flight-framework/adapter-deno';

export default defineConfig({
    adapter: deno(),
});
```

---

## Configuration

```typescript
deno({
    // Deno Deploy specific
    port: 8000,
    
    // Enable static file serving
    serveStatic: true,
    
    // Static files directory
    staticDir: 'public',
});
```

---

## Deno Deploy

### Deploy with deployctl

```bash
# Install deployctl
deno install -Arf jsr:@deno/deployctl

# Build
deno task build

# Deploy
deployctl deploy --project=my-app --prod .output/server/main.ts
```

### deno.json

```json
{
    "tasks": {
        "dev": "flight dev",
        "build": "flight build",
        "start": "deno run -A .output/server/main.ts"
    }
}
```

---

## Build Output

```
.output/
├── server/
│   └── main.ts          # Deno server entry
└── static/              # Static assets
```

---

## License

MIT
npm package: @flight-framework/adapter-docker
Description: Docker adapter for Flight Framework - optimized, production-ready containers
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-docker

# @flight-framework/adapter-docker

Docker deployment adapter for Flight Framework. Generate optimized Docker images for containerized deployments.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Generated Dockerfile](#generated-dockerfile)
- [Build and Run](#build-and-run)
- [Docker Compose](#docker-compose)
- [License](#license)

---

## Installation

```bash
npm install @flight-framework/adapter-docker
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import docker from '@flight-framework/adapter-docker';

export default defineConfig({
    adapter: docker(),
});
```

---

## Configuration

```typescript
docker({
    // Base image
    baseImage: 'node:20-alpine',
    
    // Port to expose
    port: 3000,
    
    // Run as non-root user
    user: 'node',
    
    // Include these files in the image
    include: ['package.json', 'package-lock.json'],
    
    // Build arguments
    buildArgs: {
        NODE_ENV: 'production',
    },
});
```

---

## Generated Dockerfile

After building, find the Dockerfile at `.docker/Dockerfile`:

```dockerfile
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
ENV NODE_ENV=production
RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
COPY --from=builder --chown=nodejs:nodejs /app/.output .output
COPY --from=builder /app/package*.json ./
RUN npm ci --omit=dev
USER nodejs
EXPOSE 3000
CMD ["node", ".output/server/index.mjs"]
```

---

## Build and Run

```bash
# Build
npm run build

# Build Docker image
docker build -f .docker/Dockerfile -t my-flight-app .

# Run
docker run -p 3000:3000 my-flight-app

# With environment variables
docker run -p 3000:3000 -e DATABASE_URL=... my-flight-app
```

---

## Docker Compose

```yaml
# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: .docker/Dockerfile
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://db:5432/myapp
    depends_on:
      - db
  
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:
```

---

## License

MIT
npm package: @flight-framework/adapter-fly
Description: Fly.io adapter for Flight Framework - globally distributed edge deployment
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-fly

# @flight-framework/adapter-fly

Fly.io deployment adapter for Flight Framework. Deploy globally to Fly.io's edge network.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Build Output](#build-output)
- [Deployment](#deployment)
- [License](#license)

---

## Installation

```bash
npm install @flight-framework/adapter-fly
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import fly from '@flight-framework/adapter-fly';

export default defineConfig({
    adapter: fly(),
});
```

---

## Configuration

```typescript
fly({
    // Fly app name (from fly.toml)
    appName: 'my-flight-app',
    
    // Primary region
    primaryRegion: 'iad',
    
    // Port to listen on
    port: 8080,
});
```

---

## Build Output

```
.fly/
├── Dockerfile           # Generated Dockerfile
├── fly.toml             # Fly configuration
└── app/
    ├── server/
    └── client/
```

---

## Deployment

### Fly CLI

```bash
# Install Fly CLI
curl -L https://fly.io/install.sh | sh

# Login
fly auth login

# Launch new app
fly launch

# Deploy
fly deploy
```

### fly.toml

```toml
app = "my-flight-app"
primary_region = "iad"

[build]

[http_service]
  internal_port = 8080
  force_https = true
  auto_stop_machines = true
  auto_start_machines = true

[[vm]]
  memory = "256mb"
  cpu_kind = "shared"
```

---

## License

MIT
npm package: @flight-framework/adapter-netlify
Description: Netlify adapter for Flight Framework - deploy to Netlify Functions and Edge
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/adapter-netlify

# @flight-framework/adapter-netlify

Netlify deployment adapter for Flight Framework. Deploy with serverless functions and edge middleware.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Edge Functions](#edge-functions)
- [Build Output](#build-output)
- [Deployment](#deployment)
- [Environment Variables](#environment-variables)
- [License](#license)

---

## Installation

```bash
npm install @flight-framework/adapter-netlify
```

---

## Quick Start

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import netlify from '@flight-framework/adapter-netlify';

export default defineConfig({
    adapter: netlify(),
});
```

Deploy:

```bash
npm run build
netlify deploy --prod
```

---

## Configuration

```typescript
netlify({
    // Use edge functions for SSR
    edge: false,
    
    // Netlify Functions directory
    functionsDir: 'netlify/functions',
    
    // Split routes into separate functions
    split: false,
});
```

---

## Edge Functions

For low-latency SSR at the edge:

```typescript
netlify({
    edge: true,
});
```

### Edge Middleware

```typescript
// src/middleware.ts
export default function middleware(request: Request) {
    // Run at the edge before your app
    const country = request.headers.get('x-country');
    
    if (country === 'DE') {
        return Response.redirect('/de');
    }
}

export const config = {
    path: '/*',
};
```

---

## Build Output

```
.netlify/
├── functions/
│   └── server.mjs       # SSR function
├── edge-functions/      # Edge functions (if enabled)
└── publish/
    ├── _redirects
    └── assets/          # Static files
```

---

## Deployment

### Netlify CLI

```bash
# Install CLI
npm install -g netlify-cli

# Login
netlify login

# Deploy preview
netlify deploy

# Deploy production
netlify deploy --prod
```

### netlify.toml

```toml
[build]
  command = "npm run build"
  publish = ".netlify/publish"
  functions = ".netlify/functions"

[functions]
  node_bundler = "esbuild"

[[redirects]]
  from = "/*"
  to = "/.netlify/functions/server"
  status = 200
```

---

## Environment Variables

Set in Netlify dashboard or `netlify.toml`:

```toml
[context.production.environment]
  DATABASE_URL = "..."
```

| Variable | Description |
|----------|-------------|
| `NETLIFY` | Set to `true` on Netlify |
| `CONTEXT` | `production`, `deploy-preview`, or `branch-deploy` |
| `URL` | Production URL |
| `DEPLOY_URL` | Unique deploy URL |

---

## License

MIT
npm package: @flight-framework/bundler
Description: Bundler abstraction layer for Flight Framework
Latest version: 3.0.0
Deprecated: DEPRECATED: Movido a @flightdev/bundler

# @flight-framework/bundler

Internal bundler utilities for Flight Framework. Used by the CLI and adapters.

## Installation

This is an internal package. You typically don't need to install it directly.

```bash
npm install @flight-framework/bundler
```

## Overview

The bundler package provides shared utilities for:

- **Vite Configuration**: Common Vite plugins and config
- **Rollup Integration**: Rollup plugins for SSR builds
- **esbuild Helpers**: Fast transpilation utilities
- **Code Splitting**: Optimized chunk generation
- **Tree Shaking**: Dead code elimination

## Usage (Internal)

```typescript
import { createBuildConfig, createDevConfig } from '@flight-framework/bundler';

const config = createBuildConfig({
    entry: './src/entry.ts',
    outDir: '.output',
    target: 'node',
    minify: true,
});
```

## Exports

- `createBuildConfig` - Production build configuration
- `createDevConfig` - Development server configuration
- `createSSRBuild` - Server-side rendering build
- `createClientBuild` - Client bundle build
- `analyzeBundle` - Bundle size analysis

## License

MIT
npm package: @flight-framework/bundler-esbuild
Description: esbuild bundler adapter for Flight Framework - fast and minimal
Latest version: 3.0.1
Deprecated: DEPRECATED: Movido a @flightdev/bundler-esbuild

# @flight-framework/bundler-esbuild

esbuild bundler adapter for Flight Framework.

## Installation

```bash
npm install @flight-framework/bundler-esbuild esbuild
```

## Usage

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import { esbuild } from '@flight-framework/bundler-esbuild';

export default defineConfig({
    bundler: esbuild(),
});
```

## Options

```typescript
esbuild({
    // Build target
    target: 'es2022',
    
    // Enable minification (default: true in production)
    minify: true,
    
    // Source maps
    sourcemap: true,
    
    // Output format
    format: 'esm',
    
    // Code splitting
    splitting: true,
    
    // External packages
    external: ['react', 'react-dom'],
    
    // Define global constants
    define: {
        'process.env.API_URL': '"https://api.example.com"',
    },
    
    // JSX configuration
    jsx: 'automatic',
});
```

## Performance

esbuild is extremely fast, typically 10-100x faster than Webpack or Rollup:

| Bundler | Cold Start | Rebuild |
|---------|-----------|---------|
| Vite | ~300ms | ~50ms |
| esbuild | ~50ms | ~10ms |

## Limitations

Unlike Vite, esbuild does not have:
- Built-in HMR (Hot Module Replacement)
- Native CSS Modules support (requires plugin)
- As rich plugin ecosystem

For full-featured development, consider `@flight-framework/bundler-vite`.

## CSS Support

esbuild handles CSS natively but CSS Modules require a plugin:

```bash
npm install esbuild-css-modules-plugin
```

```typescript
import cssModulesPlugin from 'esbuild-css-modules-plugin';

esbuild({
    plugins: [cssModulesPlugin()],
});
```

## License

MIT
npm package: @flight-framework/bundler-vite
Description: Vite bundler adapter for Flight Framework
Latest version: 3.0.1
Deprecated: DEPRECATED: Movido a @flightdev/bundler-vite

# @flight-framework/bundler-vite

Vite bundler adapter for Flight Framework.

## Installation

```bash
npm install @flight-framework/bundler-vite vite
```

## Usage

```typescript
// flight.config.ts
import { defineConfig } from '@flight-framework/core';
import { vite } from '@flight-framework/bundler-vite';

export default defineConfig({
    bundler: vite(),
});
```

## Options

```typescript
vite({
    // CSS configuration
    css: {
        modules: true,  // Enable CSS Modules
        devSourcemap: true,
    },
    
    // Vite-specific overrides
    vite: {
        plugins: [...],
        optimizeDeps: { ... },
    },
    
    // Framework plugins (auto-detected by default)
    react: true,
    vue: false,
});
```

## CSS Support

### CSS Modules

Flight + Vite supports CSS Modules natively. Just use `.module.css`:

```css
/* Button.module.css */
.primary {
    background: blue;
}
```

```tsx
import styles from './Button.module.css';

<button className={styles.primary}>Click</button>
```

### Tailwind CSS

Create `tailwind.config.js` and `postcss.config.js` as normal:

```bash
npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p
```

Vite will automatically use PostCSS.

### Sass/SCSS

```bash
npm install -D sass
```

Then import `.scss` files directly.

## License

MIT
npm package: @flight-framework/cache-cloudflare-kv
Description: Cloudflare Workers KV cache adapter for Flight Framework
Author: Flight Framework
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/cache-cloudflare-kv

# @flight-framework/cache-cloudflare-kv

Cloudflare KV cache adapter for Flight Framework. Edge caching with Cloudflare Workers KV.

## Installation

```bash
npm install @flight-framework/cache-cloudflare-kv
```

## Quick Start

```typescript
import { createCache } from '@flight-framework/core/cache';
import { cloudflareKV } from '@flight-framework/cache-cloudflare-kv';

// In your Cloudflare Worker
export default {
    async fetch(request, env) {
        const cache = createCache(cloudflareKV({
            binding: env.MY_KV_NAMESPACE,
        }));
        
        await cache.set('key', 'value');
        const value = await cache.get('key');
        
        return Response.json({ value });
    }
};
```

## Configuration

```typescript
cloudflareKV({
    // KV namespace binding
    binding: env.MY_KV_NAMESPACE,
    
    // Key prefix
    prefix: 'cache:',
    
    // Default TTL in seconds
    ttl: 3600,
    
    // Cache TTL for reads (edge cache duration)
    cacheTtl: 60,
});
```

## wrangler.toml

```toml
[[kv_namespaces]]
binding = "MY_KV_NAMESPACE"
id = "abc123"
```

## License

MIT
npm package: @flight-framework/cache-components
Description: Component-level caching with streaming SSR for Flight Framework
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/cache-components

# @flight-framework/cache-components

Component-level caching with streaming SSR for Flight Framework.

Enables **Partial Pre-Rendering (PPR)** patterns - mix static, cached, and dynamic content in a single route.

## Installation

```bash
pnpm add @flight-framework/cache-components
```

## Usage

### Basic Setup

```tsx
import { createCache, memory } from '@flight-framework/core';
import { CacheProvider, CachedContent, Dynamic } from '@flight-framework/cache-components/react';

const cache = createCache({ adapter: memory({ maxSize: 1000 }) });

function App() {
    return (
        <CacheProvider cache={cache} defaultTTL={3600}>
            <Header />  {/* Static */}
            
            <Suspense fallback={<ReviewsSkeleton />}>
                <CachedContent cacheKey="reviews:123" ttl={3600} tags={['reviews']}>
                    <ProductReviews productId="123" />
                </CachedContent>
            </Suspense>
            
            <Dynamic>
                <ShoppingCart />  {/* Always fresh */}
            </Dynamic>
        </CacheProvider>
    );
}
```

### Cached Data Functions

```tsx
import { cachedFn, setGlobalCache } from '@flight-framework/cache-components';

// Set up global cache
setGlobalCache(cache);

// Create cached data fetcher
const getReviews = cachedFn('reviews', async (productId: string) => {
    const res = await fetch(`/api/reviews/${productId}`);
    return res.json();
}, { ttl: 3600, tags: ['reviews'] });

// Usage
const reviews = await getReviews('product-123');
```

### Client-Side Hook

```tsx
import { useCachedData } from '@flight-framework/cache-components/react';

function Price({ productId }) {
    const { data, isLoading, error } = useCachedData(
        `price:${productId}`,
        () => fetch(`/api/price/${productId}`).then(r => r.json()),
        { ttl: 60 }
    );
    
    if (isLoading) return <Skeleton />;
    return <span>${data.price}</span>;
}
```

## API

### Components

| Component | Description |
|-----------|-------------|
| `CacheProvider` | Provides cache context to tree |
| `CachedContent` | Marks content as cached |
| `Dynamic` | Marks content as never cached |

### Functions

| Function | Description |
|----------|-------------|
| `cachedComponent` | Create cached component renderer |
| `cachedFn` | Wrap function with caching |
| `setGlobalCache` | Set global cache instance |

### Hooks

| Hook | Description |
|------|-------------|
| `useCache` | Access cache from context |
| `useCachedData` | Client-side data caching |

## Features

- SSR streaming integration
- Automatic cache key generation
- Tag-based invalidation
- DevTools instrumentation hooks
- Works with any cache adapter
npm package: @flight-framework/cache-deno-kv
Description: Deno KV cache adapter for Flight Framework - native Deno key-value store
Author: Flight Framework
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/cache-deno-kv

# @flight-framework/cache-deno-kv

Deno KV cache adapter for Flight Framework. Native Deno KV storage for edge and serverless.

## Installation

```typescript
import { denoKV } from '@flight-framework/cache-deno-kv';
```

## Quick Start

```typescript
import { createCache } from '@flight-framework/core/cache';
import { denoKV } from '@flight-framework/cache-deno-kv';

const cache = createCache(denoKV());

await cache.set('key', 'value');
const value = await cache.get('key');
```

## Configuration

```typescript
denoKV({
    // Key prefix
    prefix: ['cache'],
    
    // Default TTL in milliseconds
    ttl: 60 * 60 * 1000,
    
    // Custom KV instance (optional, uses Deno.openKv() by default)
    kv: await Deno.openKv('./data.db'),
});
```

## Features

- Zero dependencies
- ACID transactions
- Native Deno Deploy support
- Automatic serialization

## License

MIT
npm package: @flight-framework/cache-devtools
Description: DevTools for Flight cache system - metrics, profiling, and visualization
Latest version: 0.0.7
Deprecated: DEPRECATED: Movido a @flightdev/cache-devtools

# @flight-framework/cache-devtools

DevTools for Flight cache system - metrics, profiling, and visualization.

## Installation

```bash
pnpm add @flight-framework/cache-devtools
```

## Usage

### Enable DevTools

```typescript
import { enableDevTools } from '@flight-framework/cache-devtools';

if (process.env.NODE_ENV === 'development') {
    enableDevTools();
}
```

### Add Panel to App

```tsx
import { CacheDevToolsPanel } from '@flight-framework/cache-devtools/panel';

function App() {
    return (
        <>
            <MainApp />
            {process.env.NODE_ENV === 'development' && (
                <CacheDevToolsPanel position="bottom-right" />
            )}
        </>
    );
}
```

### Access Metrics Programmatically

```typescript
import { getMetrics, getTimeline, getEntries } from '@flight-framework/cache-devtools';

const metrics = getMetrics();
console.log(`Hit rate: ${metrics.hitRate * 100}%`);
console.log(`Cached entries: ${metrics.entriesCount}`);
```

## Features

- Real-time hit/miss tracking
- Timeline of cache operations
- Entry-level metrics
- Invalidation tracking
- Error monitoring
npm package: @flight-framework/cache-lru
Description: LRU (Least Recently Used) cache adapter for Flight Framework - bounded memory cache with eviction
Author: Flight Framework
Latest version: 0.0.7
Deprecated: DEPRECATED: Movido a @flightdev/cache-lru

# @flight-framework/cache-lru

In-memory LRU cache adapter for Flight Framework. Fast, size-bounded caching.

## Installation

```bash
npm install @flight-framework/cache-lru
```

## Quick Start

```typescript
import { createCache } from '@flight-framework/core/cache';
import { lru } from '@flight-framework/cache-lru';

const cache = createCache(lru({
    max: 1000,       // Max entries
    ttl: 60 * 1000,  // Default TTL in ms
}));

await cache.set('key', 'value');
const value = await cache.get('key');
```

## Configuration

```typescript
lru({
    // Maximum number of entries
    max: 1000,
    
    // Maximum size in bytes (alternative to max)
    maxSize: 50 * 1024 * 1024,  // 50MB
    
    // Size calculator for maxSize
    sizeCalculation: (value) => JSON.stringify(value).length,
    
    // Default TTL in milliseconds
    ttl: 60 * 1000,
    
    // Update TTL on access
    updateAgeOnGet: true,
    
    // Allow stale values while revalidating
    allowStale: true,
});
```

## Features

- O(1) get/set/delete operations
- Size-bounded with LRU eviction
- TTL support
- Stale-while-revalidate
- No external dependencies

## License

MIT
npm package: @flight-framework/cache-redis
Description: Redis cache adapter for Flight Framework using ioredis
Author: Flight Framework
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/cache-redis

# @flight-framework/cache-redis

Redis cache adapter for Flight Framework. Production-ready caching with Redis.

## Table of Contents

- [Installation](#installation)
- [Quick Start](#quick-start)
- [Configuration](#configuration)
- [Usage](#usage)
- [Cluster Mode](#cluster-mode)
- [API Reference](#api-reference)
- [License](#license)

---

## Installation

```bash
npm install @flight-framework/cache-redis ioredis
```

---

## Quick Start

```typescript
import { createCache } from '@flight-framework/core/cache';
import { redis } from '@flight-framework/cache-redis';

const cache = createCache(redis({
    url: process.env.REDIS_URL,
}));

// Set a value
await cache.set('user:123', { name: 'John', email: 'john@example.com' });

// Get a value
const user = await cache.get('user:123');

// Delete a value
await cache.delete('user:123');
```

---

## Configuration

```typescript
redis({
    // Redis URL
    url: 'redis://localhost:6379',
    
    // Or individual options
    host: 'localhost',
    port: 6379,
    password: 'secret',
    db: 0,
    
    // Key prefix
    prefix: 'myapp:cache:',
    
    // Default TTL in seconds
    ttl: 3600,
    
    // Enable TLS
    tls: true,
    
    // Connection options
    maxRetriesPerRequest: 3,
    connectTimeout: 10000,
});
```

---

## Usage

### Basic Operations

```typescript
// Set with TTL
await cache.set('key', 'value', { ttl: 60 });

// Get
const value = await cache.get('key');

// Check existence
const exists = await cache.has('key');

// Delete
await cache.delete('key');

// Clear all
await cache.clear();
```

### With Fetch

Fetch from cache or compute if missing:

```typescript
const user = await cache.fetch('user:123', async () => {
    return await db.users.findById(123);
}, { ttl: 300 });
```

### Tags

Invalidate groups of keys:

```typescript
await cache.set('products:1', data, { tags: ['products'] });
await cache.set('products:2', data, { tags: ['products'] });

// Invalidate all products
await cache.invalidateTag('products');
```

---

## Cluster Mode

```typescript
import { redisCluster } from '@flight-framework/cache-redis';

const cache = createCache(redisCluster({
    nodes: [
        { host: 'node1.example.com', port: 6379 },
        { host: 'node2.example.com', port: 6379 },
        { host: 'node3.example.com', port: 6379 },
    ],
    password: 'secret',
}));
```

---

## API Reference

### Adapter Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `url` | `string` | - | Redis URL |
| `host` | `string` | `'localhost'` | Redis host |
| `port` | `number` | `6379` | Redis port |
| `password` | `string` | - | Password |
| `db` | `number` | `0` | Database number |
| `prefix` | `string` | `''` | Key prefix |
| `ttl` | `number` | `3600` | Default TTL |
| `tls` | `boolean` | `false` | Enable TLS |

---

## License

MIT
npm package: @flight-framework/cache-tiered
Description: Tiered/layered cache adapter for Flight Framework - combine multiple cache layers
Author: Flight Framework
Latest version: 0.0.7
Deprecated: DEPRECATED: Movido a @flightdev/cache-tiered

# @flight-framework/cache-tiered

Tiered cache adapter for Flight Framework. Combine multiple cache layers for optimal performance.

## Installation

```bash
npm install @flight-framework/cache-tiered
```

## Quick Start

```typescript
import { createCache } from '@flight-framework/core/cache';
import { tiered } from '@flight-framework/cache-tiered';
import { lru } from '@flight-framework/cache-lru';
import { redis } from '@flight-framework/cache-redis';

const cache = createCache(tiered([
    lru({ max: 100, ttl: 60000 }),        // L1: Fast in-memory
    redis({ url: process.env.REDIS_URL }), // L2: Shared Redis
]));

// Reads check L1 first, then L2
// Writes go to all layers
await cache.set('key', 'value');
const value = await cache.get('key');
```

## Configuration

```typescript
tiered([
    // Layers in order of priority (fastest first)
    memoryAdapter,
    redisAdapter,
    s3Adapter,  // For very large/cold data
], {
    // Write to all layers on set (default: true)
    writeThrough: true,
    
    // Populate faster layers on cache miss (default: true)
    populateOnMiss: true,
});
```

## How It Works

1. **Read**: Check L1 -> L2 -> L3 until found
2. **Write**: Write to all layers
3. **Miss**: Populate faster layers with the value

## License

MIT
npm package: @flight-framework/storage
Description: Storage adapters for Flight Framework - S3, R2, FS, and more
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/storage

# @flight-framework/storage

File storage package with cloud provider adapters.

## Installation

```bash
npm install @flight-framework/storage
```

## Quick Start

```typescript
import { createStorage } from '@flight-framework/storage';
import { s3 } from '@flight-framework/storage/s3';

const storage = createStorage(s3({
    bucket: 'my-bucket',
    region: 'us-east-1',
}));

// Upload
await storage.put('files/document.pdf', file);

// Download
const data = await storage.get('files/document.pdf');

// Delete
await storage.delete('files/document.pdf');
```

## Adapters

### AWS S3

```typescript
import { s3 } from '@flight-framework/storage/s3';

const adapter = s3({
    bucket: 'my-bucket',
    region: 'us-east-1',
    credentials: {
        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    },
});
```

### Cloudflare R2

```typescript
import { r2 } from '@flight-framework/storage/r2';

const adapter = r2({
    accountId: process.env.CF_ACCOUNT_ID,
    bucket: 'my-bucket',
    accessKeyId: process.env.R2_ACCESS_KEY_ID,
    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
});
```

### Local Filesystem

```typescript
import { fs } from '@flight-framework/storage/fs';

const adapter = fs({
    basePath: './uploads',
});
```

## API Reference

### storage.put(key, data, options?)

Upload a file.

```typescript
await storage.put('path/file.txt', buffer, {
    contentType: 'text/plain',
    metadata: { uploadedBy: 'user123' },
});
```

### storage.get(key)

Download a file.

```typescript
const data = await storage.get('path/file.txt');
```

### storage.getUrl(key, options?)

Get a signed URL.

```typescript
const url = await storage.getUrl('path/file.txt', {
    expiresIn: 3600, // 1 hour
});
```

### storage.delete(key)

Delete a file.

```typescript
await storage.delete('path/file.txt');
```

### storage.list(prefix?)

List files.

```typescript
const files = await storage.list('uploads/');
```

## License

MIT
npm package: @flight-framework/vite
Description: Vite plugin for Flight Framework - development and build integration
Latest version: 0.0.6
Deprecated: DEPRECATED: Movido a @flightdev/vite

# @flight-framework/vite

Vite plugin for Flight Framework.

## Installation

```bash
npm install @flight-framework/vite
```

## Usage

```typescript
// vite.config.ts
import { defineConfig } from 'vite';
import flight from '@flight-framework/vite';

export default defineConfig({
    plugins: [
        flight(),
    ],
});
```

## Configuration

```typescript
flight({
    ssr: true,                    // Enable SSR
    routesDir: 'src/routes',      // Routes directory
    extensions: ['.tsx', '.ts'],  // File extensions
});
```

## Features

- Automatic route discovery
- SSR support
- Hot module replacement for routes
- Server action compilation
- Optimized production builds

## License

MIT
npm package: @flightdeck/eleventy-react-icons
Description: React Icons for Eleventy
Author: Copilot Dev
Latest version: 0.5.2

# Eleventy React Icons

A configurable Eleventy shortcode that outputs React Icons icon svgs in a custom svg sprite.

## Usage

### Installation

`npm install --save-dev @flightdeck/eleventy-react-icons`

### Adding to Eleventy

In .eleventy.js:

```js
// require
const { ReactIcon } = require("@flightdeck/eleventy-react-icons");
module.exports = function (config) {
  // Shortcode
  config.addNunjucksShortcode("ReactIcon", ReactIcon);
  //
};
```

#### In package.json, you can configure the folder where the SVG Sprite will be output:

```js
{...
  "config": {
    "reactIconPath": "./src/img/", // defaults to "/"
    "reactIconOutputFolder": "./foo/bar", // defaults to "./dist"
  },
...}
```

### In any nunjucks template file:

#### Use the shortcode:

```
{% ReactIcon name = "FaBeer" %}
```

#### Props:

- **name:** the icon name

\*\* other properties will get applied to the wrapper tag as attributes

```
{% ReactIcon name="FaBeer", class="text-2xl lg:text-3xl", style="margin-left:20px" %}
```

### CSS

Default styles for an icon can be imported from `@flightdeck/eleventy-react-icons/icon.css`;
They are pretty bare bones, so feel free to use them or not:

```css
.icon svg {
  display: block;
  width: 1em;
  height: 1em;
}
```