diff --git a/.bowerrc b/.bowerrc new file mode 100644 index 0000000..c88f1fd --- /dev/null +++ b/.bowerrc @@ -0,0 +1,4 @@ +{ + "registry": "https://bower.herokuapp.com" + +} diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..1a0a316 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,23 @@ +# http://editorconfig.org +root = true + +[*] +indent_style = space +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true + +[*.md] +trim_trailing_whitespace = false + +[*.json] +indent_size = 2 +insert_final_newline = false + +[src/**/*] +trim_trailing_whitespace = false + +[.npmrc] +insert_final_newline = false diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0d6dcc2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,115 @@ +# Created by .ignore support plugin (hsz.mobi) +### OSX template +*.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff: +.idea/workspace.xml +.idea/tasks.xml +.idea/dictionaries +.idea/vcs.xml +.idea/jsLibraryMappings.xml + +# Sensitive or high-churn files: +.idea/dataSources.ids +.idea/dataSources.xml +.idea/dataSources.local.xml +.idea/sqlDataSources.xml +.idea/dynamic.xml +.idea/uiDesigner.xml + +# Gradle: +.idea/gradle.xml +.idea/libraries + +# Mongo Explorer plugin: +.idea/mongoSettings.xml +.idea/ +.idea/* + +## File-based project format: +*.iws + +## Plugin-specific files: + +# IntelliJ +/out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties +### Node template +# Logs +logs +*.log +npm-debug.log* + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +node_modules +jspm_packages + +# Optional npm cache directory +.npm + +# Optional REPL history +.node_repl_history + +/.idea/ +/bower_components/ diff --git a/.jscsrc b/.jscsrc new file mode 100644 index 0000000..f8bf9ba --- /dev/null +++ b/.jscsrc @@ -0,0 +1,6 @@ +{ + "requireCamelCaseOrUpperCaseIdentifiers": true, + "requireCapitalizedConstructors": true, + "requireParenthesesAroundIIFE": true, + "validateQuoteMarks": "'" +} diff --git a/.jshintrc b/.jshintrc new file mode 100644 index 0000000..9797d31 --- /dev/null +++ b/.jshintrc @@ -0,0 +1,13 @@ +{ + "bitwise": true, + "browser": true, + "curly": true, + "eqeqeq": true, + "esnext": true, + "latedef": true, + "noarg": true, + "node": true, + "strict": true, + "undef": true, + "unused": true +} diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..7f1e1f9 --- /dev/null +++ b/.npmignore @@ -0,0 +1,120 @@ +# Created by .ignore support plugin (hsz.mobi) +### OSX template +*.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff: +.idea/workspace.xml +.idea/tasks.xml +.idea/dictionaries +.idea/vcs.xml +.idea/jsLibraryMappings.xml + +# Sensitive or high-churn files: +.idea/dataSources.ids +.idea/dataSources.xml +.idea/dataSources.local.xml +.idea/sqlDataSources.xml +.idea/dynamic.xml +.idea/uiDesigner.xml + +# Gradle: +.idea/gradle.xml +.idea/libraries + +# Mongo Explorer plugin: +.idea/mongoSettings.xml +.idea/ +.idea/* + +## File-based project format: +*.iws + +## Plugin-specific files: + +# IntelliJ +/out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties +### Node template +# Logs +logs +*.log +npm-debug.log* + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +node_modules +jspm_packages + +# Optional npm cache directory +.npm + +# Optional REPL history +.node_repl_history + +/.idea/ +/bower_components/ + +dist_browser/ +bower.json +.bowerrc +bin/EventEmitter.browser.js diff --git a/.npmrc b/.npmrc new file mode 100644 index 0000000..e1531a3 --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ +registry = https://registry.npmjs.org \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..94c36d0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2016, Lilian Saget-Lethias + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..4c6f4d1 --- /dev/null +++ b/README.md @@ -0,0 +1,46 @@ +# eventemitter-promise + +Event Emitter with lazy promise ! (see http://github.com/bios21/superlazypromise) + +## Installation + +Then install it via npm: + +``` bash +$ npm install --save eventemitter-promise +``` + +Or via bower: + +``` bash +$ bower install --save eventemitter-promise +``` + +## Example Usage + +Each listener are stored to be fired later on a `SuperLazyPromise` + +| emit\on | event | event.* | event.context | event.context! | +|:--------------:|:-----:|:-------:|:-------------:|:--------------:| +| event | ✓ | ✓ | ✓ | ✓ | +| event.context | ✓ | | ✓ | ✓ | +| event.context! | | | ✓ | ✓ | + +**!** : Firing an event on strict context (`event.context!`) is not yet implemented. + +``` js +const EventEmitter = require('eventemitter-promise'); + +class Clazz extends EventEmitter { + emit() { + } + on() { + } +} +``` + + +License +---- + +ISC License. See the `LICENSE` file. diff --git a/bin/EventEmitter.browser.js b/bin/EventEmitter.browser.js new file mode 100644 index 0000000..3713aee --- /dev/null +++ b/bin/EventEmitter.browser.js @@ -0,0 +1,189 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _module = null, + _exports = null; +if (module && module.exports) { + _exports = module.exports; + _module = { + SuperLazyPromise: require('superlazypromise').SuperLazyPromise + }; +} else { + _exports = window; + _module = _exports; +} + +(function (module, exports) { + var SuperLazyPromise = module.SuperLazyPromise; + + var EMPTY_FN = function EMPTY_FN() {}, + NS_SEPARATOR = '.'; + + var EventEmitter = function () { + function EventEmitter() { + _classCallCheck(this, EventEmitter); + + this._promises = new Map(); + } + + _createClass(EventEmitter, [{ + key: 'on', + value: function on(event) { + var SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + if (!promiseMainEvent) { + promiseMainEvent = new SuperLazyPromise(SLP.fn); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + SLP = new SuperLazyPromise(promiseMainEvent.fn); + SLP.updatePromise(promiseMainEvent.promise); + this._promises.set(event, SLP); + } else { + this._promises.set(splitEvent[0], new SuperLazyPromise(EMPTY_FN)); + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + } else { + if (!SLP) { + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + return this._promises.get(event); + } + }, { + key: 'off', + value: function off(event) { + if (!event.includes(NS_SEPARATOR)) { + this._destroyPromise(event); + } else { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = this._promises[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var keyVal = _step.value; + + if (keyVal[0].split(NS_SEPARATOR)[0] === event) { + this._destroyPromise(keyVal[0]); + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + } + }, { + key: '_destroyPromise', + value: function _destroyPromise(event) { + this._promises[event].kill(); + delete this._promises[event]; + } + }, { + key: 'emit', + value: function emit(event) { + for (var _len = arguments.length, data = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + data[_key - 1] = arguments[_key]; + } + + var executor = function executor(ok, ko) { + return ok.apply(undefined, data); + }; + + var SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + SLP.awake(executor); + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + } else { + promiseMainEvent = new SuperLazyPromise(EMPTY_FN); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } else { + promiseMainEvent = new SuperLazyPromise(executor); + promiseMainEvent.awake(); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } + } + } else { + if (SLP) { + SLP.awake(executor); + } else { + SLP = new SuperLazyPromise(executor); + SLP.awake(); + this._promises.set(event, SLP); + } + + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = this._promises[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var keyVal = _step2.value; + + if (keyVal[0].includes(NS_SEPARATOR) && keyVal[0].split(NS_SEPARATOR)[0] === event) { + var subEvent = keyVal[0], + subPromise = this._promises.get(subEvent); + subPromise.updatePromise(SLP.promise); + subPromise.awake(); + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + } + } + }]); + + return EventEmitter; + }(); + + exports.EventEmitter = EventEmitter; +})(_module, _exports); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["EventEmitter.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"../bin/EventEmitter.browser.js","sourcesContent":["'use strict';\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _module = null,\n    _exports = null;\nif (module && module.exports) {\n    _exports = module.exports;\n    _module = {\n        SuperLazyPromise: require('superlazypromise').SuperLazyPromise\n    };\n} else {\n    _exports = window;\n    _module = _exports;\n}\n\n(function (module, exports) {\n    var SuperLazyPromise = module.SuperLazyPromise;\n\n    var EMPTY_FN = function EMPTY_FN() {},\n        NS_SEPARATOR = '.';\n\n    var EventEmitter = function () {\n        function EventEmitter() {\n            _classCallCheck(this, EventEmitter);\n\n            this._promises = new Map();\n        }\n\n        _createClass(EventEmitter, [{\n            key: 'on',\n            value: function on(event) {\n                var SLP = this._promises.get(event),\n                    hasContext = event.includes(NS_SEPARATOR),\n                    splitEvent = event.split(NS_SEPARATOR),\n                    promiseMainEvent = this._promises.get(splitEvent[0]);\n\n                if (hasContext) {\n                    if (SLP) {\n                        if (!promiseMainEvent) {\n                            promiseMainEvent = new SuperLazyPromise(SLP.fn);\n                            promiseMainEvent.updatePromise(SLP.promise);\n                            this._promises.set(splitEvent[0], promiseMainEvent);\n                        }\n                    } else {\n                        if (promiseMainEvent) {\n                            SLP = new SuperLazyPromise(promiseMainEvent.fn);\n                            SLP.updatePromise(promiseMainEvent.promise);\n                            this._promises.set(event, SLP);\n                        } else {\n                            this._promises.set(splitEvent[0], new SuperLazyPromise(EMPTY_FN));\n                            this._promises.set(event, new SuperLazyPromise(EMPTY_FN));\n                        }\n                    }\n                } else {\n                    if (!SLP) {\n                        this._promises.set(event, new SuperLazyPromise(EMPTY_FN));\n                    }\n                }\n                return this._promises.get(event);\n            }\n        }, {\n            key: 'off',\n            value: function off(event) {\n                if (!event.includes(NS_SEPARATOR)) {\n                    this._destroyPromise(event);\n                } else {\n                    var _iteratorNormalCompletion = true;\n                    var _didIteratorError = false;\n                    var _iteratorError = undefined;\n\n                    try {\n                        for (var _iterator = this._promises[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                            var keyVal = _step.value;\n\n                            if (keyVal[0].split(NS_SEPARATOR)[0] === event) {\n                                this._destroyPromise(keyVal[0]);\n                            }\n                        }\n                    } catch (err) {\n                        _didIteratorError = true;\n                        _iteratorError = err;\n                    } finally {\n                        try {\n                            if (!_iteratorNormalCompletion && _iterator.return) {\n                                _iterator.return();\n                            }\n                        } finally {\n                            if (_didIteratorError) {\n                                throw _iteratorError;\n                            }\n                        }\n                    }\n                }\n            }\n        }, {\n            key: '_destroyPromise',\n            value: function _destroyPromise(event) {\n                this._promises[event].kill();\n                delete this._promises[event];\n            }\n        }, {\n            key: 'emit',\n            value: function emit(event) {\n                for (var _len = arguments.length, data = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n                    data[_key - 1] = arguments[_key];\n                }\n\n                var executor = function executor(ok, ko) {\n                    return ok.apply(undefined, data);\n                };\n\n                var SLP = this._promises.get(event),\n                    hasContext = event.includes(NS_SEPARATOR),\n                    splitEvent = event.split(NS_SEPARATOR),\n                    promiseMainEvent = this._promises.get(splitEvent[0]);\n\n                if (hasContext) {\n                    if (SLP) {\n                        SLP.awake(executor);\n                        if (promiseMainEvent) {\n                            promiseMainEvent.awake(executor);\n                        } else {\n                            promiseMainEvent = new SuperLazyPromise(EMPTY_FN);\n                            promiseMainEvent.updatePromise(SLP.promise);\n                            this._promises.set(splitEvent[0], promiseMainEvent);\n                        }\n                    } else {\n                        if (promiseMainEvent) {\n                            promiseMainEvent.awake(executor);\n                            SLP = new SuperLazyPromise(EMPTY_FN);\n                            SLP.updatePromise(promiseMainEvent.promise);\n                        } else {\n                            promiseMainEvent = new SuperLazyPromise(executor);\n                            promiseMainEvent.awake();\n                            SLP = new SuperLazyPromise(EMPTY_FN);\n                            SLP.updatePromise(promiseMainEvent.promise);\n                        }\n                    }\n                } else {\n                    if (SLP) {\n                        SLP.awake(executor);\n                    } else {\n                        SLP = new SuperLazyPromise(executor);\n                        SLP.awake();\n                        this._promises.set(event, SLP);\n                    }\n\n                    var _iteratorNormalCompletion2 = true;\n                    var _didIteratorError2 = false;\n                    var _iteratorError2 = undefined;\n\n                    try {\n                        for (var _iterator2 = this._promises[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n                            var keyVal = _step2.value;\n\n                            if (keyVal[0].includes(NS_SEPARATOR) && keyVal[0].split(NS_SEPARATOR)[0] === event) {\n                                var subEvent = keyVal[0],\n                                    subPromise = this._promises.get(subEvent);\n                                subPromise.updatePromise(SLP.promise);\n                                subPromise.awake();\n                            }\n                        }\n                    } catch (err) {\n                        _didIteratorError2 = true;\n                        _iteratorError2 = err;\n                    } finally {\n                        try {\n                            if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                                _iterator2.return();\n                            }\n                        } finally {\n                            if (_didIteratorError2) {\n                                throw _iteratorError2;\n                            }\n                        }\n                    }\n                }\n            }\n        }]);\n\n        return EventEmitter;\n    }();\n\n    exports.EventEmitter = EventEmitter;\n})(_module, _exports);"],"sourceRoot":"/source/"} diff --git a/bin/EventEmitter.node.js b/bin/EventEmitter.node.js new file mode 100644 index 0000000..3cba73c --- /dev/null +++ b/bin/EventEmitter.node.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('../dist_node/EventEmitter').EventEmitter; diff --git a/bower.json b/bower.json new file mode 100644 index 0000000..8544c04 --- /dev/null +++ b/bower.json @@ -0,0 +1,26 @@ +{ + "name": "eventemitter-promise", + "description": "Event Emitter with lazy promise.", + "main": "bin/EventEmitter.browser.js", + "authors": [ + "Lilian Saget-Lethias (http://github.com/bios21)" + ], + "license": "ISC", + "keywords": [ + "event", + "eventemitter", + "lazy", + "promise", + "a+", + "then", + "thenable" + ], + "homepage": "https://github.com/bios21/eventemitter-promise#readme", + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "test", + "tests" + ] +} diff --git a/dist_node/EventEmitter.js b/dist_node/EventEmitter.js new file mode 100644 index 0000000..75a6d6e --- /dev/null +++ b/dist_node/EventEmitter.js @@ -0,0 +1,131 @@ +'use strict'; + +var _module = null, + _exports = null; +if (module && module.exports) { + _exports = module.exports; + _module = { + SuperLazyPromise: require('superlazypromise').SuperLazyPromise + }; +} else { + _exports = window; + _module = _exports; +} + +((module, exports) => { + const SuperLazyPromise = module.SuperLazyPromise; + + const EMPTY_FN = function EMPTY_FN() {}, + NS_SEPARATOR = '.'; + + class EventEmitter { + constructor() { + this._promises = new Map(); + } + + on(event) { + let SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + if (!promiseMainEvent) { + promiseMainEvent = new SuperLazyPromise(SLP.fn); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + SLP = new SuperLazyPromise(promiseMainEvent.fn); + SLP.updatePromise(promiseMainEvent.promise); + this._promises.set(event, SLP); + } else { + this._promises.set(splitEvent[0], new SuperLazyPromise(EMPTY_FN)); + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + } else { + if (!SLP) { + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + return this._promises.get(event); + } + + off(event) { + if (!event.includes(NS_SEPARATOR)) { + this._destroyPromise(event); + } else { + for (let keyVal of this._promises) { + if (keyVal[0].split(NS_SEPARATOR)[0] === event) { + this._destroyPromise(keyVal[0]); + } + } + } + } + + _destroyPromise(event) { + this._promises[event].kill(); + delete this._promises[event]; + } + + emit(event) { + for (var _len = arguments.length, data = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + data[_key - 1] = arguments[_key]; + } + + const executor = (ok, ko) => ok.apply(undefined, data); + + let SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + SLP.awake(executor); + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + } else { + promiseMainEvent = new SuperLazyPromise(EMPTY_FN); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } else { + promiseMainEvent = new SuperLazyPromise(executor); + promiseMainEvent.awake(); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } + } + } else { + if (SLP) { + SLP.awake(executor); + } else { + SLP = new SuperLazyPromise(executor); + SLP.awake(); + this._promises.set(event, SLP); + } + + for (let keyVal of this._promises) { + if (keyVal[0].includes(NS_SEPARATOR) && keyVal[0].split(NS_SEPARATOR)[0] === event) { + let subEvent = keyVal[0], + subPromise = this._promises.get(subEvent); + subPromise.updatePromise(SLP.promise); + subPromise.awake(); + } + } + } + } + } + + exports.EventEmitter = EventEmitter; +})(_module, _exports); +//# sourceMappingURL=data:application/json;base64,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 diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..d4cce30 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,42 @@ +const gulp = require('gulp'), + clean = require('gulp-clean'), + babel = require('gulp-babel'), + sourcemaps = require('gulp-sourcemaps'), + gutil = require('gulp-util'), + concat = require('gulp-concat'); + +gulp.task('build', () => { + gutil.log('Build for Node ...'); + gulp.src('src/**/*.js') + .pipe(babel({ + presets: ['es2015-node4'], + comments: false + }).on('error', err => gutil.log('Some shit appends for node dist ... ', err.message))) + .pipe(sourcemaps.init()) + .pipe(sourcemaps.write()) + .pipe(gulp.dest('dist_node')); + + gutil.log('Build for browser ...'); + gulp.src('src/**/*.js') + .pipe(babel({ + presets: ['es2015'], + comments: false + }).on('error', err => gutil.log('Some shit appends for browser dist ...', err.message))) + .pipe(sourcemaps.init()) + .pipe(concat('../bin/EventEmitter.browser.js')) + .pipe(sourcemaps.write()) + .pipe(gulp.dest('dist_browser')); +}); + +gulp.task('clean', () => { + gulp.src(['dist_node/**/*', 'dist_browser/**/*', 'temp'], {read: false}) + .pipe(clean()) +}); + +gulp.task('watch', ['cleanBuild'], () => { + gulp.watch(['bower.json', 'src/index.html'], ['bower']); + gulp.watch('src/**/*.js', ['build']); +}); + +gulp.task('default', ['watch']); +gulp.task('cleanBuild', ['clean', 'build']); diff --git a/package.json b/package.json new file mode 100644 index 0000000..ade53dd --- /dev/null +++ b/package.json @@ -0,0 +1,45 @@ +{ + "name": "eventemitter-promise", + "version": "0.0.1", + "description": "Event Emitter with lazy promise.", + "main": "bin/EventEmitter.node.js", + "scripts": { + "test": "mocha test/*.js" + }, + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/bios21/eventemitter-promise.git" + }, + "keywords": [ + "event", + "eventemitter", + "lazy", + "promise", + "a+", + "then", + "thenable" + ], + "devDependencies": { + "babel": "^6.5.2", + "babel-cli": "^6.10.1", + "babel-preset-es2015": "^6.9.0", + "babel-preset-es2015-node4": "^2.1.0", + "gulp": "^3.9.1", + "gulp-babel": "^6.1.2", + "gulp-clean": "^0.3.2", + "gulp-concat": "^2.6.0", + "gulp-sourcemaps": "^1.6.0", + "gulp-util": "^3.0.7", + "mocha": "^2.5.3", + "should": "^9.0.2" + }, + "author": "Lilian Saget-Lethias (http://github.com/bios21)", + "license": "ISC", + "bugs": { + "url": "https://github.com/bios21/eventemitter-promise/issues" + }, + "homepage": "https://github.com/bios21/eventemitter-promise#readme", + "dependencies": { + "superlazypromise": "0.0.1" + } +} diff --git a/src/EventEmitter.js b/src/EventEmitter.js new file mode 100644 index 0000000..3719e6a --- /dev/null +++ b/src/EventEmitter.js @@ -0,0 +1,188 @@ +'use strict'; + +var _module = null, + _exports = null; +if (module && module.exports) { + _exports = module.exports; + _module = { + SuperLazyPromise: require('superlazypromise').SuperLazyPromise + }; +} else { + _exports = window; + _module = _exports; +} + +((module, exports) => { + const SuperLazyPromise = module.SuperLazyPromise; + + const EMPTY_FN = function() {}, + NS_SEPARATOR = '.'; + + /** + * A manager for listening and emitting event on a object. + * + * + * Each listener are stored to be fired later on a `SuperLazyPromise` + * + * | emit\on | event | event.* | event.context | event.context! | + * |:--------------:|:-----:|:-------:|:-------------:|:--------------:| + * | event | ✓ | ✓ | ✓ | ✓ | + * | event.context | ✓ | | ✓ | ✓ | + * | event.context! | | | ✓ | ✓ | + * + * **!** : Firing an event on strict context (`event.context!`) is not yet implemented. + * + * @abstract + */ + class EventEmitter { + + /** + * Build the internal super lazy promise pool. + */ + constructor() { + + /** + * @type {Map} + * @private + */ + this._promises = new Map(); + } + + /** + * Listen the given event. + * Contrary to classic event manager like `addEventListener` for DOM, `EventEmitter` provide a `Promise`-like + * to manipulate instead of a callback. + * + * This `Promise` will be **SuperLazy** which means that it will be active only when we fire it. + * + * See `SuperLazyPromise` for more explanation. + * + * @param {String} event Type of event with context or not + * @return {LazyPromise} The promise to manipulate + * + * @see SuperLazyPromise + * @listening event + */ + on(event) { + let SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + if (!promiseMainEvent) { + promiseMainEvent = new SuperLazyPromise(SLP.fn); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + SLP = new SuperLazyPromise(promiseMainEvent.fn); + SLP.updatePromise(promiseMainEvent.promise); + this._promises.set(event, SLP); + } else { + this._promises.set(splitEvent[0], new SuperLazyPromise(EMPTY_FN)); + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + } else { + if (!SLP) { + this._promises.set(event, new SuperLazyPromise(EMPTY_FN)); + } + } + return this._promises.get(event); + } + + /** + * Stop listening on the given event. + * The promise stored by `on` or `emit` will become not usable. + * + * @param {String} event Type of event with context or not + * @listened event + */ + off(event) { + if (!event.includes(NS_SEPARATOR)) { + this._destroyPromise(event); + } else { + for (let keyVal of this._promises) { + if (keyVal[0].split(NS_SEPARATOR)[0] === event) { + this._destroyPromise(keyVal[0]); + } + } + } + } + + /** + * Kill & destroy a lazy promise to prevent future use. + * + * @param {String} event Type of event with context or not + * @private + */ + _destroyPromise(event) { + this._promises[event].kill(); + delete this._promises[event]; + } + + /** + * Emit a possibly listened event and call the function associated with some param. + * See the array in class description for event specific firing. + * + * @param {String} event Type of event with context or not + * @param {...*} data What is fired to the first listener + * + * @emit event + */ + emit(event, ...data) { + const executor = (ok, ko) => ok(...data); + + let SLP = this._promises.get(event), + hasContext = event.includes(NS_SEPARATOR), + splitEvent = event.split(NS_SEPARATOR), + promiseMainEvent = this._promises.get(splitEvent[0]); + + if (hasContext) { + if (SLP) { + SLP.awake(executor); + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + } else { + promiseMainEvent = new SuperLazyPromise(EMPTY_FN); + promiseMainEvent.updatePromise(SLP.promise); + this._promises.set(splitEvent[0], promiseMainEvent); + } + } else { + if (promiseMainEvent) { + promiseMainEvent.awake(executor); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } else { + promiseMainEvent = new SuperLazyPromise(executor); + promiseMainEvent.awake(); + SLP = new SuperLazyPromise(EMPTY_FN); + SLP.updatePromise(promiseMainEvent.promise); + } + } + } else { + if (SLP) { + SLP.awake(executor); + } else { + SLP = new SuperLazyPromise(executor); + SLP.awake(); + this._promises.set(event, SLP); + } + + for (let keyVal of this._promises) { + if (keyVal[0].includes(NS_SEPARATOR) && keyVal[0].split(NS_SEPARATOR)[0] === event) { + let subEvent = keyVal[0], + subPromise = this._promises.get(subEvent); + subPromise.updatePromise(SLP.promise); + subPromise.awake(); + } + } + } + } + } + + exports.EventEmitter = EventEmitter; +})(_module, _exports); diff --git a/test/test.js b/test/test.js new file mode 100644 index 0000000..8e49954 --- /dev/null +++ b/test/test.js @@ -0,0 +1,130 @@ +'use strict'; + +const EventEmitter = require('../dist_node/EventEmitter').EventEmitter, + mocha = require('mocha'), + should = require('should'); + +console.log(EventEmitter); + +describe('EventEmitter', () => { + describe('on/emit event => event', () => { + it('should emit and listen on event', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event', 'test'); + }); + + it('should emit on event and listen on event.test', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event.test').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event', 'test'); + }); + + it('should emit on event.test and listen on event', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event.test', 'test'); + }); + + + it('should emit on "tneve" and listen on event without receiving', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event').then(anything => { + anything.should.not.be.eql('test'); + done(new Error('Should not be here.')); + }); + + test.emit('tneve', 'test'); + done(); + }); + }); + + describe('on/emit event.* => event.*', () => { + it('should emit and listen on event', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event.test').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event.test', 'test'); + }); + + it('should emit on event and listen on event.test', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event.test').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event', 'test'); + }); + + it('should emit on event.test and listen on event', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event').then(anything => { + anything.should.be.eql('test'); + done(); + }); + + test.emit('event.test', 'test'); + }); + + + it('should emit on "tneve" and listen on event without receiving', done => { + class Test extends EventEmitter { + + } + + let test = new Test(); + test.on('event').then(anything => { + anything.should.not.be.eql('test'); + done(new Error('Should not be here.')); + }); + + test.emit('tneve', 'test'); + done(); + }); + }); + +});