Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/prestaul/enum-props

Enums with support for additional metadata
https://github.com/prestaul/enum-props

Last synced: about 19 hours ago
JSON representation

Enums with support for additional metadata

Awesome Lists containing this project

README 

        
# Introduction



enum-props wraps the excellent enum implementation [adrai/enum](https://github.com/adrai/enum). It exposes an Enum factory that allows additional metadata to be added to each enum member.



## Installation

```bash

npm install -S enum-props

```



## Usage

```js

var Enum = require('enum-props');



// define a simple enum (automatically flaggable -> A: 0x01, B: 0x02, C: 0x04)

//Uses bitwise 'OR' operation in between the values and creates enumerated constants. For example, if 'Read':1, 'Write':2, then ReadWrite= Read | Write = 1 | 2 = 3;

var myEnum = new Enum(['A', 'B', 'C']);



//define a flagged enum object to create a multicolor option; just pass an array

var myEnum = new Enum(['Black', 'Red', 'Green', 'Blue']);

myEnum; //=> Enum {_options: Object, enums: Array[4], Black: EnumItem, Red: EnumItem, Green: EnumItem….....}

myEnum.isFlaggable; //=> true



for(var i=1; i<8; i++){ console.log(myEnum.get(i).value + '=> '+ myEnum.get(i).key)}

    1=> Black

    2=> Red

    3=> Black | Red

    4=> Green

    5=> Black | Green

    6=> Red | Green

    7=> Black | Red | Green



// define an enum with own values

var myEnum = new Enum({'A': 1, 'B': 2, 'C': 4});



//define enum type without flag

var myEnum = new Enum({'None': 0, 'Black':1, 'Red': 2, 'Red2': 3, 'Green': 4, 'Blue': 5});

myEnum; //=>  Enum {_options: Object, enums: Array[6], None: EnumItem, Black: EnumItem, Red: EnumItem...}

myEnum.isFlaggable; //=> false



for(var i=0; i<=5; i++){ console.log(myEnum.get(i).value + '=> '+ myEnum.get(i).key)}

    0=> None

    1=> Black

    2=> Red

    3=> Red2

    4=> Green

    5=> Blue



// define an enum with own custom properties

var myEnum = new Enum({

    'A': { value: 1, description: 'first' }, 

    'B': { value: 2, description: 'second' }, 

    'C': { value: 4, description: 'third' }

});



myEnum.A.value // => 1

myEnum.A.description // => 'first'



// enums and their members are frozen

myEnum.A.description = 'this is ignored'

myEnum.A.description // => 'first'



// iterating over an enum

myEnum.enums.forEach(function(enumItem) {

  console.log(enumItem.key);

});

// => None

// => Black

// => Red

// => Red2

// => Green

// => Blue



// get your item

myEnum.A



// or

myEnum.get('A')



// or

myEnum.get(1)



// or

myEnum.get('A | B')



// or

myEnum.get(3)



// get your value

myEnum.A.value



// get your key

myEnum.A.key



// get all items

myEnum.enums // returns all enums in an array



// compare

myEnum.A.is(myEnum.A)



// or

myEnum.A.is('A')



// or

myEnum.A.is(1)



// or

myEnum.A == 'A'



// or

myEnum.A == myEnum.A



// or

myEnum.A === myEnum.A



// check flag

var myItem = myEnum.get(3); // or [myEnum.get('A | B')]

myItem.has(myEnum.A)



// or

myItem.has('A')



// or

myItem.has(1)



// other functions

myItem.toString() // returns 'A | C'

myItem.toJSON() // returns '"A | C"'

myItem.valueOf() // returns 3



JSON.stringify(myItem) // returns '"A | C"'



//Type Safety:

//Newly created enumerable objects are Type-Safe in a way that it's non-configurable and no longer extensible.

//Each EnumItem has a beack-reference to a constructor and they are implicitly final.

Object.getOwnPropertyDescriptor(myEnum, 'Red'); //=> Object {value: EnumItem, writable: false, enumerable: true, configurable: false}

Object.isExtensible(myEnum); //=> false

myEnum instanceof Enum; //=> true



//Instances of Enum created with 'new' from similar objects are not equal

myEnum1=new Enum({'A':1, 'B':2, 'C':4});

myEnum2=new Enum({'A':1, 'B':2, 'C':4});

myEnum1 == myEnum2 //=> false

myEnum1.A == myEnum2.A //=> false

myEnum1.A.value == myEnum2.A.value //=> true



//This enum object has no properties other than those defined during its creation. Existing Data is 'Persistent' and preserves the original version

myEnum.B.value; //=> 2

myEnum.B = 5; //=> Throws TypeError

delete myEnum.B; //=> false

myEnum.D = 6; //=> doesn't add to the enum object, silently ignores

myEnum.D; // undefined



//Try to define new property throws TypeError

Object.defineProperty(myEnum, D, {value:6, writable:false, enumerable:true});

//=>TypeError: Cannot define property:D, object is not extensible.

```