prototype-extension v0.2.2

prototype-extension 0.2.2

###Extension methods brought to javascript

##How does it work ? ###I. Create an extension

// ./string-extension.js

module.exports = class StringExtension
{
    static toInt(self)
    {
        return +self
    }
}

###II. Extend a type with your extension class

// ./main.js

const PrototypeExtension = require("prototype-extension")
const StringExtension = require("./string-extension")

String._.extendWith(StringExtension)
// This can work too:
// ""._.extendWith(StringExtension)

It will allow you to use the StringExtension methods on every string of your module. It won't affect the other modules, neither the ones which import yours.

###III. Use your extension method

// ./main.js

/*
 * Previous code
 */

console.log(typeof "42"._.toInt()) // => number

##Choose your accessor name Go into your package.json and add this section:

{
    /* Your package.json stuff */
    "prototype-extension": {
        "accessor": "$$"
    },
    /* Your other package.json stuff */
}

Now, the default accessor will be "$$" in your module.

String.$$.extendWith(StringExtension)
"123".$$.toInt()

It's useful to avoid conflicts with lodash and underscore.

##See which extensions are accessibles

""._.__extensions__()
// => {
//    StringExtension: Function StringExtension,
//    PrototypeExtension: Function PrototypeExtension
// }

This will show every extensions available for this type (even the inherited ones)

To have more information, you call it like this:

""._.__extensions__(true) // __extensions__(self, complete=false)
// => {
//    _: {
//      String: { StringExtension: Function StringExtension },
//      Object: { PrototypeExtension: Function PrototypeExtension }
//    }
// }

It will indicate how to access the extensions, on which type the extension came from and all the extensions for the types of the prototype chain.

##See which extension methods are accessibles

""._.__extensionmethods__()
// => {
//    toInt: Function toInt
//    extendWith: Function extendWith
//    __extensions__: Function __extensions__
//    __extensionmethods__: Function __extensionmethods__
//    __protochain__: Function __protochain__
//    __protoproperties__: Function __protoproperties__
// }

This will show every extension methods available for this type (even the inherited ones)

To have more information, you call it like this:

""._.__extensionmethods__(true)
// => {
//    _: {
//      String: {
//          StringExtension: {
//              toInt: Function toInt
//          }
//      },
//      Object: {
//          PrototypeExtension: {
//              extendWith: Function extendWith
//              __extensions__: Function __extensions__
//              __extensionmethods__: Function __extensionmethods__
//              __protochain__: Function __protochain__
//              __protoproperties__: Function __protoproperties__
//          }
//      }
//    }
// }

##Unextend your prototype

String._.unextendWith(StringExtension)

""._.toInt => Will throw an error
""._.__extensions__().StringExtension // undefined
""._.__extensionmethods__().toInt // undefined

It will affect your whole module. Every strings won't be able to use the StringExtensions methods. However, it won't affect the node_modules (either the ones you use or the ones that use yours)

#You can't...

##see the extensions added in a node_module and a node_module can't see your extensions

You can't add methods dynamically on your extension after extending your prototype.

String._.extendWith(StringExtension)
StringExtension.dynamicMethod = function (self) { return "dynamicMethod" }
""._.dynamicMethod() // => Will throw an error

##add twice the same extension on the same prototype

String._.extendWith(StringExtension)
String._.extendWith(StringExtension) // Will throw an error

But this will work

class A {}
class B extends A {}

class Extension {}
A._.extendWith(Extension)
B._.extendWith(Extension)

##add two extension with the same method name on the same prototype

class A {}

class ExtensionHello {
    static method(self) {
        console.log('Hello')
    }
}

class ExtensionWorld {
    static method(self) {
        console.log('World')
    }
}

A._.extendWith(ExtensionHello)
A._.extendWith(ExtensionWorld) // Will throw an error

###But this

class A {}
class B extends A {}

class ExtensionHello {
    static method(self) {
        console.log('Hello')
    }
}

class ExtensionWorld {
    static method(self) {
        console.log('World')
    }
}

A._.extendWith(ExtensionHello)
B._.extendWith(ExtensionWorld) // Will work

new A()._.method() // => 'Hello'
new B()._.method() // => 'World'

#Be careful

const obj = {}
obj._ // or obj.yourAccessor will always be true

// So you can't expect this to work as usual
obj._ || (obj._ = "value")

###but

const obj = {}
obj.hasOwnProperty("_") // => false

obj._ = "Hello"
obj.hasOwnProperty("_") // => true

##Threading No tests were made for testing this. If you use a library for threading, you should process with caution. It should work, but there is no guarantee.