enum

Introduction

Enum is a javascript module that introduces the Enum Type. It works for node.js, in the browser and for deno.

...and ref compatible Known Types

Download

Releases for a browser are available for download from GitHub.

Version	Description	Size
enum-3.0.4.js	uncompressed, with comments	Download
enum-3.0.4.min.js	compressed, without comments	Download

Installation (node.js)

$ npm install enum

Installation (browser)

download the standalone file

Usage

// use it as module
const Enum = require('enum')
 
// or with import
import Enum from 'enum'
 
// or in deno
import Enum from 'https://deno.land/x/enum/index.js'
 
// or in browser
<script src="enum.js"></script>
 
// or extend node.js, deno or browser global/window with this new type
Enum.register()
 
// 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
const myEnum = new Enum(['A', 'B', 'C'])
 
//define a flagged enum object to create a multicolor option just pass an array
const myEnum = new Enum(['Black', 'Red', 'Green', 'Blue'])
myEnum //=> Enum {_options: Object, enums: Array[4], Black: EnumItem, Red: EnumItem, Green: EnumItem….....}
myEnum.isFlaggable //=> true
 
for (let 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
const myEnum = new Enum({'A': 1, 'B': 2, 'C': 4})
 
// if defining a flaggable enum, you can define your own separator (default is ' | ')
const myEnum = new Enum(['A', 'B', 'C'], { separator: ' | ' })
 
// if you want your enum to have a name define it in the options
const myEnum = new Enum(['A', 'B', 'C'], { name: 'MyEnum' })
 
// or
const myEnum = new Enum(['A', 'B', 'C'], 'MyEnum')
 
// if you want your enum to have an explicit "endianness", define it in the options
// (defaults to `os.endianness()`)
const myEnum = new Enum(['A', 'B', 'C'], { endianness: 'BE' })
 
// if you want your enum to be not case sensitive
// (defaults to `false`)
const myEnum = new Enum(['One', 'tWo', 'ThrEE'], { ignoreCase: true })
myEnum.get('one') // => myEnum.One
myEnum.get('TWO') // => myEnum.tWo
myEnum.ThrEE.is('three') // => true
 
// this option will make instances of Enum non-extensible
// (defaults to `false`)
const myEnum = new Enum(['ONE', 'TWO', 'THREE'], { freeze: true })
 
//define enum type without flag
const 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
 
myEnum.toJSON() // returns {'None': 0, 'Black':1, 'Red': 2, 'Red2': 3, 'Green': 4, 'Blue': 5}
JSON.stringify(myEnum) // returns '{"None":0,"Black":1,"Red":2,"Red2":3,"Green":4,"Blue":5}'
 
for(const 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
 
// 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
 
// check if it's defined
myEnum.isDefined(myEnum.A) // returns true
myEnum.isDefined('A')      // returns true
myEnum.isDefined(1)        // returns true
 
// compare
myEnum.A.is(myEnum.A)
 
// or
myEnum.A.is('A')
 
// or
myEnum.A.is(1)
 
// or
myEnum.A == myEnum.A
 
// or
myEnum.A === myEnum.A
 
 
// check flag
const 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.