# flumix

**Repository Path**: mirrors_jfromaniello/flumix

## Basic Information

- **Project Name**: flumix
- **Description**: Mix classes fluently
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-05-30
- **Last Updated**: 2026-05-31

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Flumix

A lightweight, type-safe mixin library for TypeScript that enables composable class inheritance with a fluent API.

## Installation

```bash
npm install flumix
```

## Features

- 🔒 **Type-safe**: Full TypeScript support with proper type inference
- 🧩 **Composable**: Easily combine multiple mixins with a fluent API
- 🪶 **Lightweight**: Zero dependencies, minimal footprint
- 🔧 **Flexible**: Works with any class hierarchy

## Usage

### Basic Example

```typescript
import { mix } from "flumix";

// Base class
class Animal {
  isAlive = true;
}

// Mixin functions
function Swimming(Base) {
  return class extends Base {
    swim() {
      return "Swimming!";
    }
  };
}

function Flying(Base) {
  return class extends Base {
    fly() {
      return "Flying!";
    }
  };
}

// Create a class that combines Animal with Swimming and Flying abilities
const Duck = mix(Animal).with(Swimming).with(Flying).build();

// Use the composed class
const duck = new Duck();
console.log(duck.isAlive); // true
console.log(duck.swim()); // "Swimming!"
console.log(duck.fly()); // "Flying!"
```

### With Constructor Parameters

```typescript
// Base class with constructor
class Person {
  name: string;

  constructor(name: string) {
    this.name = name;
  }
}

// Mixin with options
function Aged(Base, defaultAge: number) {
  return class extends Base {
    age: number;

    constructor(...args: any[]) {
      super(...args);
      this.age = defaultAge;
    }

    getAge() {
      return this.age;
    }
  };
}

// Create a composed class with parameters
const AgedPerson = mix(Person).with(Aged, 30).build();

const person = new AgedPerson("John");
console.log(person.name); // "John"
console.log(person.getAge()); // 30
```

## API

### `mix(BaseClass)` / `extend(BaseClass)`

Both functions are identical and create a new `MixinBuilder` for the given base class.

### `MixinBuilder.with(mixinFn, ...options)`

Applies a mixin function to the current base class, optionally with additional parameters.

### `MixinBuilder.build()`

Finalizes the mixin chain and returns the resulting class.

## Compatibility

- Works with ES6+ environments
- Full TypeScript support (4.0+)

## License

MIT © [José F. Romaniello](https://github.com/jfromaniello)