wrasse - npm Package Compare versions

Comparing version 0.0.1 to 0.1.0

lib/wrasse.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 Wrasse = (function () {
+  /**
+   * @constructor
+   */
+
+  function Wrasse() {
+    _classCallCheck(this, Wrasse);
+
+    this.dependencies = new Map();
+    this.modules = new Map();
+  }
+
+  /**
+   * @decoratable
+   * @param  {{[string]: String|Symbol}} keys
+   * @return {(target: Function): void}
+   */
+
+  _createClass(Wrasse, [{
+    key: "inject",
+    value: function inject(keys) {
+      var _this = this;
+
+      return function (target) {
+        _this.dependencies.set(target, keys);
+        var deps = _this.dependencies.get(target);
+        for (var modKey in deps) {
+          if (!Object.hasOwnProperty.call(deps, modKey)) {
+            break;
+          }
+          target.prototype[modKey] = _this.modules.get(deps[modKey]);
+        }
+        return target;
+      };
+    }
+
+    /**
+     * @param  {String|Symbol} key
+     * @param  {*}             value
+     * @return {void}
+     */
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      this.modules.set(key, value);
+    }
+  }]);
+
+  return Wrasse;
+})();
+
+exports["default"] = Wrasse;
+module.exports = exports["default"];

index.js

@@ -10,7 +10,7 @@ /* eslint-disable */
 
-var _libInjector = require('./lib/injector');
+var _libWrasse = require('./lib/wrasse');
 
-var _libInjector2 = _interopRequireDefault(_libInjector);
+var _libWrasse2 = _interopRequireDefault(_libWrasse);
 
-exports['default'] = _libInjector2['default'];
+exports['default'] = _libWrasse2['default'];
 module.exports = exports['default'];

package.json

 {
   "name": "wrasse",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "JavaScript dependency injection with the Decorators syntax.",
@@ -20,3 +20,3 @@ "main": "index.js",
   },
-  "author": "ChatWork",
+  "author": "OKUNOKENTARO @armorik83",
   "license": "MIT",
@@ -23,0 +23,0 @@ "devDependencies": {

README.md

@@ -1,2 +0,99 @@
-#wrasse
+# wrasse
 JavaScript dependency injection with the Decorators syntax.
+
+## Installing
+```
+npm i -S wrasse
+```
+
+## Getting Started
+First, you can instantiate Wrasse and it needs export. Because it is necessary to solve Wrasse instantiation before any import, it is cut out as a single source.
+
+For example, as `wrasse-singleton.js`.
+
+```
+import Wrasse from 'wrasse';
+const wr = new Wrasse();
+export default wr;
+```
+
+---
+
+Second, you can set a module. You must register the key to get the module.
+
+**`register-dependencies.js`**
+
+```
+import wr from './wrasse-singleton';
+
+import _ComponentA from './component-a';
+import _ComponentB from './component-b';
+import _ComponentC from './component-c';
+
+import {
+  ComponentA,
+  ComponentB,
+  ComponentC
+} from './module-keys';
+
+wr.set(ComponentA, _ComponentA);
+wr.set(ComponentB, _ComponentB);
+wr.set(ComponentC, _ComponentC);
+
+export default wr;
+```
+
+**`module-keys.js`**
+
+```
+export const ComponentA = Symbol('ComponentA');
+export const ComponentB = Symbol('ComponentB');
+export const ComponentC = Symbol('ComponentC');
+
+// Or, it can also be a string.
+
+// export const ComponentA = 'ComponentA';
+// export const ComponentB = 'ComponentB';
+// export const ComponentC = 'ComponentC';
+```
+
+## Usage
+You can use the inject in your implementation with Babel.
+(TypeScript is unverified. We have plan to support.)
+
+```
+babel --optional es7.decorators
+```
+
+```
+import wr from './register-dependencies';
+
+import {
+  ComponentA,
+  ComponentB,
+  ComponentC
+} from './module-keys';
+
[e-mail]({
+  ComponentA,
+  ComponentB,
+  ComponentC
+})
+export default class Application {
+  constructor() {
+    console.log(this.ComponentA); // 格納済み
+  }
+}
+```
+
+## API
+- `Wrasse`
+- `Wrasse#set(key: string|Symbol, module: any): void`
+- `Wrasse#inject(keys: {[key: string]: string|Symbol}): constructor @decoratable`
+
+## Author
+- [OKUNOKENTARO @armorik83](https://github.com/armorik83)
+
+## License
+MIT
+https://github.com/chatwork/wrasse/blob/master/LICENSE

No alert changes

Improved metrics

Total package byte prevSize

8297

84.99%

Number of package files

6

20%

Lines of code

121

72.86%

Number of lines in readme file

100

3233.33%

No dependency changes