# interface

**Repository Path**: mirrors_WebReflection/interface

## Basic Information

- **Project Name**: interface
- **Description**: Simple interfaces for modern JavaScript.
- **Primary Language**: Unknown
- **License**: ISC
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-19
- **Last Updated**: 2025-12-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# interface [![Build Status](https://travis-ci.org/WebReflection/interface.svg?branch=master)](https://travis-ci.org/WebReflection/interface) [![Coverage Status](https://coveralls.io/repos/github/WebReflection/interface/badge.svg?branch=master)](https://coveralls.io/github/WebReflection/interface?branch=master)

Simple interfaces for modern JavaScript.

`npm -i @webreflection/interface`

### API
There are two functions usable through `Object` or any `Function.prototype`:

  * `Object.interface([iFace, ...iFace, ]{object: 'literal'})` to defines left to right interfaces properties on top of the newly created interface
  * `Object.implements(iFace[, ...iFace])` to create a new object that implements all interfaces (still left to right)

Both methods can be also used to define classes:

  * `Function.interface([iFace, ...iFace, ]class {})` to defines left to right classes implementing the optional list of previous interfaces as parameters
  * `class extends AnyClass.implements(iFace[, ...iFace])` to create a new intermediate class that implements all interfaces (still left to right)


#### Peculiarities

  * all interfaces properties and symbols are forced as non enumerable
  * all interfaces are created through the same internal class with a `null` object as prototype

Last point means that objects interfaces do not have toString methods or constructors.
These are indeed meant to be used as interfaces only, not as generic objects.


### Example
```js
// Function.prototype polluted, deal with it!
require('@webreflection/interface');

// an interface is just an object
// carrying some definition that can be implemented
// through other objects or classes
const EventListener = Object.interface({
  handleEvent(e) { this['on' + e.type](e); }
});

// but it can be defined through a class too
// in such case you can even new EventListener
// or directly extends EventListener
const EventListener = Function.interface(class {
  handleEvent(e) { this['on' + e.type](e); }
});

// a simple clicker class (it could directly extends EventListener too)
class Clicker {
  constructor() { super(); this.clicks = 0; }
  onclick(e) {
    e.preventDefault();
    console.log(`You clicked me ${++this.clicks} times`);
  }
}

// a BasicClicker that extends Clicker and implements EventListener
class BasicClicker extends Clicker.implements(EventListener) {
  constructor(node) {
    super();
    node.addEventListener('click', this);
  }
}

new BasicClicker(document.documentElement);
```