A JavaScript library for creating complex objects and properties, intuitively.

npm install def
1 downloads in the last week
10 downloads in the last month

Basic Usage

named function only

myObj.def(function namedFunction(){});
 // -> //gets name from function itself, can only be named in source or with eval, not dynamic
  { namedFunction: Function namedFunction }

property name and any value

myObj.def('myProp', 5000);
 // -> // simple property, config/enum/write = true
  { myProp: 5000 }

getter/setter non-backward compatible syntax

  get myProp(){ return 5000; },
  set myProp(val){ 'some setter logic'; }
 // ->
  { myProp: [Getter/Setter] }

Controlling enumerable, writable, configurable


myObj.def('_hiddenProp', 'somevalue');
 // -> //non-enumerable, invisible unless you use getOwnPropertyNames, '_' sliced
  { [hiddenProp]: 'somevalue' }


myObj.def(function $superImportantFunction(){});
 // -> //non-configurable (no delete or redefine), '$' sliced
  { [superImportantFunction]: Function $superImportantFunction }


myObj.def('SOMECONSTANT', 'this value is constant');
 // -> //non-writable (can still be changed using configurability, AKA delete and redefine)
  { SOMECONSTANT: 'this value is constant' }

Multiple properties, still using above rules


  property1: 'simpleValue',
  get prop2(){ return 'get/setter using non-backcompat syntax' },
  set prop2(val){ this.powerLevel = 9001; },
  _someFunc: function(){ console.log("can't effectively use named functions with a dict =(") }
 // ->
  { property1: 'simplValue',
    prop2: [Getter/Setter],
    [someFunc]: Function }

array of named functions

  function firstFunction(){ console.log('whatever:' + this); },
  function getSecrets(){ return getSecretsFromDB('teehee'); },
  function setSecrets(val){ sendSecretsToDB(val); },
  function _stealSecretsForBlackMarket(){ return getAllSecretsFromDB_unlogged(); },
 // ->
  { firstFunction: Function firstFunction,
    Secrets: [Getter/Setter],
    [stealSecretsForBlackMarket]: Function _stealSecretsForBlackMarket }

Private variables

Private values are detected by the existence of an extra parameter on the get or set functions. These aren't valid getters and setters to JavaScript but they will be wrapped such that they share a private value inaccessible from anywhere else, but shared between the getter and setter functions. The private value is passed in each time, along with the passed in value for setters.

  myPrivate: {
    get: function(privateValue){
      return privateValue.somePublicProperty;
    set: function(privateValue, newValue){
      if (newValue.secreyKey === privateValue.unlockKey)
        return newValue;
      } else {
        return privateValue.somePublicProperty;
npm loves you