implab/implabjs-core Commit - r41:eae7e609c38a

tests

cin -

r41:eae7e609c38a di-typescript

parent child

Context file:

r41:eae7e609c38a

Collapse all files

test/ts/mock/Bar.ts created 644 +3 0

@@ -0,0 +1,3
	1	export class Bar {
	2	name = "bar";
	3	}

test/ts/mock/Foo.ts created 644 +3 0

@@ -0,0 +1,3
	1	export class Foo {
	2	name = "foo";
	3	}

license +1 -1

-            Copyright 2017-2018 Implab team
+            Copyright 2017-2019 Implab team
             Redistribution and use in source and binary forms, with or without
             modification, are permitted provided that the following conditions are met:
 . Redistributions of source code must retain the above copyright notice, this
             list of conditions and the following disclaimer.
 . Redistributions in binary form must reproduce the above copyright notice,
             this list of conditions and the following disclaimer in the documentation
             and/or other materials provided with the distribution.
             THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
             ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
             WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
             DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
             FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
             DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
             SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
             CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
             OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
             OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package-lock.json +7 -7

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "lockfileVersion": 1,
               "requires": true,
               "dependencies": {
                 "@types/node": {
                   "version": "10.12.12",
                   "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.12.tgz",
                   "integrity": "sha512-Pr+6JRiKkfsFvmU/LK68oBRCQeEg36TyAbPhc2xpez24OOZZCuoIhWGTd39VZy6nGafSbxzGouFPTFD/rR1A0A==",
                   "dev": true
                 },
                 "@types/tape": {
                   "version": "4.2.32",
                   "resolved": "http://registry.npmjs.org/@types/tape/-/tape-4.2.32.tgz",
                   "integrity": "sha512-xil0KO5wkPoixdBWGIGolPv9dekf6dVkjjJLAFYchfKcd4DICou67rgGCIO7wAh3i5Ff/6j9IDgZz+GU9cMaqQ==",
                   "dev": true,
                   "requires": {
                     "@types/node": "*"
                   }
                 },
                 "balanced-match": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
                   "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
                   "dev": true
                 },
                 "brace-expansion": {
                   "version": "1.1.11",
                   "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
                   "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                   "dev": true,
                   "requires": {
                     "balanced-match": "^1.0.0",
                     "concat-map": "0.0.1"
                   }
                 },
                 "concat-map": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
                   "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
                   "dev": true
                 },
                 "core-util-is": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
                   "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
                   "dev": true
                 },
                 "deep-equal": {
                   "version": "0.1.2",
                   "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-0.1.2.tgz",
                   "integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
                   "dev": true
                 },
                 "define-properties": {
                   "version": "1.1.3",
                   "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
                   "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
                   "dev": true,
                   "requires": {
                     "object-keys": "^1.0.12"
                   },
                   "dependencies": {
                     "object-keys": {
                       "version": "1.0.12",
                       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
                       "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
                       "dev": true
                     }
                   }
                 },
                 "defined": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
                   "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
                   "dev": true
                 },
                 "dojo": {
                   "version": "1.13.0",
                   "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.13.0.tgz",
                   "integrity": "sha512-mGoGvsXAbPkUrBnxCoO7m6CFH8jvWq7rAL7fP7jrhJEOyswA/bZwWdXwEH0ovs68t8S0+xOpV/3V7addYbaiAA=="
                 },
                 "duplexer": {
                   "version": "0.1.1",
-                  "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
+                  "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
                   "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
                   "dev": true
                 },
                 "es-abstract": {
                   "version": "1.12.0",
                   "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz",
                   "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==",
                   "dev": true,
                   "requires": {
                     "es-to-primitive": "^1.1.1",
                     "function-bind": "^1.1.1",
                     "has": "^1.0.1",
                     "is-callable": "^1.1.3",
                     "is-regex": "^1.0.4"
                   }
                 },
                 "es-to-primitive": {
                   "version": "1.2.0",
                   "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz",
                   "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.4",
                     "is-date-object": "^1.0.1",
                     "is-symbol": "^1.0.2"
                   }
                 },
                 "faucet": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/faucet/-/faucet-0.0.1.tgz",
                   "integrity": "sha1-WX3PHSGJosBiMhtZHo8VHtIDnZw=",
                   "dev": true,
                   "requires": {
                     "defined": "0.0.0",
                     "duplexer": "~0.1.1",
                     "minimist": "0.0.5",
                     "sprintf": "~0.1.3",
                     "tap-parser": "~0.4.0",
                     "tape": "~2.3.2",
                     "through2": "~0.2.3"
                   },
                   "dependencies": {
                     "tape": {
                       "version": "2.3.3",
-                      "resolved": "http://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
+                      "resolved": "https://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
                       "integrity": "sha1-Lnzgox3wn41oUWZKcYQuDKUFevc=",
                       "dev": true,
                       "requires": {
                         "deep-equal": "~0.1.0",
                         "defined": "~0.0.0",
                         "inherits": "~2.0.1",
                         "jsonify": "~0.0.0",
                         "resumer": "~0.0.0",
                         "through": "~2.3.4"
                       }
                     }
                   }
                 },
                 "for-each": {
                   "version": "0.3.3",
                   "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
                   "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.3"
                   }
                 },
                 "fs.realpath": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
                   "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
                   "dev": true
                 },
                 "function-bind": {
                   "version": "1.1.1",
                   "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
                   "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
                   "dev": true
                 },
                 "glob": {
                   "version": "7.1.3",
                   "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
                   "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
                   "dev": true,
                   "requires": {
                     "fs.realpath": "^1.0.0",
                     "inflight": "^1.0.4",
                     "inherits": "2",
                     "minimatch": "^3.0.4",
                     "once": "^1.3.0",
                     "path-is-absolute": "^1.0.0"
                   }
                 },
                 "has": {
                   "version": "1.0.3",
                   "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
                   "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
                   "dev": true,
                   "requires": {
                     "function-bind": "^1.1.1"
                   }
                 },
                 "has-symbols": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz",
                   "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=",
                   "dev": true
                 },
                 "inflight": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
                   "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
                   "dev": true,
                   "requires": {
                     "once": "^1.3.0",
                     "wrappy": "1"
                   }
                 },
                 "inherits": {
                   "version": "2.0.3",
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
                   "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
                   "dev": true
                 },
                 "is-callable": {
                   "version": "1.1.4",
                   "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz",
                   "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==",
                   "dev": true
                 },
                 "is-date-object": {
                   "version": "1.0.1",
                   "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz",
                   "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=",
                   "dev": true
                 },
                 "is-regex": {
                   "version": "1.0.4",
                   "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
                   "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
                   "dev": true,
                   "requires": {
                     "has": "^1.0.1"
                   }
                 },
                 "is-symbol": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz",
                   "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==",
                   "dev": true,
                   "requires": {
                     "has-symbols": "^1.0.0"
                   }
                 },
                 "isarray": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
                   "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
                   "dev": true
                 },
                 "jsonify": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
                   "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=",
                   "dev": true
                 },
                 "minimatch": {
                   "version": "3.0.4",
                   "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
                   "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
                   "dev": true,
                   "requires": {
                     "brace-expansion": "^1.1.7"
                   }
                 },
                 "minimist": {
                   "version": "0.0.5",
                   "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
                   "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                   "dev": true
                 },
                 "object-inspect": {
                   "version": "1.6.0",
                   "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz",
                   "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==",
                   "dev": true
                 },
                 "object-keys": {
                   "version": "0.4.0",
                   "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
                   "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
                   "dev": true
                 },
                 "once": {
                   "version": "1.4.0",
                   "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
                   "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
                   "dev": true,
                   "requires": {
                     "wrappy": "1"
                   }
                 },
                 "path-is-absolute": {
                   "version": "1.0.1",
-                  "resolved": "http://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+                  "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
                   "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
                   "dev": true
                 },
                 "path-parse": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
                   "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
                   "dev": true
                 },
                 "readable-stream": {
                   "version": "1.1.14",
-                  "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+                  "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
                   "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
                   "dev": true,
                   "requires": {
                     "core-util-is": "~1.0.0",
                     "inherits": "~2.0.1",
                     "isarray": "0.0.1",
                     "string_decoder": "~0.10.x"
                   }
                 },
                 "requirejs": {
                   "version": "2.3.6",
                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz",
                   "integrity": "sha512-ipEzlWQe6RK3jkzikgCupiTbTvm4S0/CAU5GlgptkN5SO6F3u0UD0K18wy6ErDqiCyP4J4YYe1HuAShvsxePLg==",
                   "dev": true
                 },
                 "resolve": {
                   "version": "1.7.1",
                   "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
                   "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==",
                   "dev": true,
                   "requires": {
                     "path-parse": "^1.0.5"
                   }
                 },
                 "resumer": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
                   "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                   "dev": true,
                   "requires": {
                     "through": "~2.3.4"
                   }
                 },
                 "sprintf": {
                   "version": "0.1.5",
                   "resolved": "https://registry.npmjs.org/sprintf/-/sprintf-0.1.5.tgz",
                   "integrity": "sha1-j4PjmpMXwaUCy324BQ5Rxnn27c8=",
                   "dev": true
                 },
                 "string.prototype.trim": {
                   "version": "1.1.2",
                   "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz",
                   "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                   "dev": true,
                   "requires": {
                     "define-properties": "^1.1.2",
                     "es-abstract": "^1.5.0",
                     "function-bind": "^1.0.2"
                   }
                 },
                 "string_decoder": {
                   "version": "0.10.31",
-                  "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+                  "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
                   "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
                   "dev": true
                 },
                 "tap-parser": {
                   "version": "0.4.3",
                   "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-0.4.3.tgz",
                   "integrity": "sha1-pOrhkMENdsehEZIf84u+TVjwnuo=",
                   "dev": true,
                   "requires": {
                     "inherits": "~2.0.1",
                     "readable-stream": "~1.1.11"
                   }
                 },
                 "tape": {
                   "version": "4.9.1",
                   "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.1.tgz",
                   "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==",
                   "dev": true,
                   "requires": {
                     "deep-equal": "~1.0.1",
                     "defined": "~1.0.0",
                     "for-each": "~0.3.3",
                     "function-bind": "~1.1.1",
                     "glob": "~7.1.2",
                     "has": "~1.0.3",
                     "inherits": "~2.0.3",
                     "minimist": "~1.2.0",
                     "object-inspect": "~1.6.0",
                     "resolve": "~1.7.1",
                     "resumer": "~0.0.0",
                     "string.prototype.trim": "~1.1.2",
                     "through": "~2.3.8"
                   },
                   "dependencies": {
                     "deep-equal": {
                       "version": "1.0.1",
                       "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
                       "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
                       "dev": true
                     },
                     "defined": {
                       "version": "1.0.0",
                       "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz",
                       "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
                       "dev": true
                     },
                     "minimist": {
                       "version": "1.2.0",
                       "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
                       "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
                       "dev": true
                     }
                   }
                 },
                 "through": {
                   "version": "2.3.8",
-                  "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
+                  "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
                   "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
                   "dev": true
                 },
                 "through2": {
                   "version": "0.2.3",
-                  "resolved": "http://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
+                  "resolved": "https://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
                   "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=",
                   "dev": true,
                   "requires": {
                     "readable-stream": "~1.1.9",
                     "xtend": "~2.1.1"
                   }
                 },
                 "typescript": {
                   "version": "3.2.1",
                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.1.tgz",
                   "integrity": "sha512-jw7P2z/h6aPT4AENXDGjcfHTu5CSqzsbZc6YlUIebTyBAq8XaKp78x7VcSh30xwSCcsu5irZkYZUSFP1MrAMbg==",
                   "dev": true
                 },
                 "wrappy": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
                   "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
                   "dev": true
                 },
                 "xtend": {
                   "version": "2.1.2",
                   "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz",
                   "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
                   "dev": true,
                   "requires": {
                     "object-keys": "~0.4.0"
                   }
                 }
               }
             }

src/ts/di/ActivationContext.ts +29 -31

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
             import { Descriptor, ServiceMap, isDescriptor } from "./interfaces";
             import { Container } from "./Container";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo {
                 name: string;
-                service: Descriptor;
+                service: string;
                 scope: ServiceMap;
             }
             export class ActivationContext {
                 _cache: object;
                 _services: ServiceMap;
                 _stack: ActivationContextInfo[];
                 _visited: object;
+                _name: string;
+                _localized: boolean;
                 container: Container;
-                constructor(container: Container, services: ServiceMap, cache?: object, visited?) {
+                constructor(container: Container, services: ServiceMap, name?: string, cache?: object, visited?) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
+                    this._name = name;
                     this._visited = visited || {};
                     this._stack = [];
                     this._cache = cache || {};
                     this._services = services;
                     this.container = container;
                 }
-                getService(name, def?): any {
+                getName() {
+                    return this._name;
+                }
+                resolve(name, def?): any {
                     const d = this._services[name];
                     if (!d)
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
-                    return isDescriptor(d) ? d.activate(this, name) : d;
+                    return this.activate(d, name);
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
                 register(name: string, service: Descriptor) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service;
                 }
                 clone() {
                     return new ActivationContext(
                         this.container,
-                        Object.create(this._services),
+                        this._services,
+                        this._name,
                         this._cache,
                         this._visited
                     );
                 }
                 has(id: string) {
                     return id in this._cache;
                 }
                 get(id: string) {
                     return this._cache[id];
                 }
                 store(id: string, value) {
                     return (this._cache[id] = value);
                 }
-                parse(data, name: string) {
+                activate(d: Descriptor, name: string) {
-                    if (isPrimitive(data))
+                    if (trace.isLogEnabled())
-                        return data;
+                        trace.log(`enter ${name} ${d}`);
-                    if (isDescriptor(data)) {
+                    this.enter(name, d.toString());
-                        return data.activate(this, name);
+                    const v = d.activate(this);
-                    } else if (data instanceof Array) {
-                        this.enter(name);
-                        const v = data.map( (x, i) => this.parse(x, `[${i}]`));
                     this.leave();
+                    if (trace.isLogEnabled())
+                        trace.log(`leave ${name}`);
                     return v;
-                    } else {
-                        this.enter(name);
-                        const result = {};
-                        for (const p in data)
-                            result[p] = this.parse(data[p], "." + p);
-                        this.leave();
-                        return result;
                 }
                 visit(id: string) {
                     const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack() {
                     return this._stack.slice().reverse();
                 }
-                enter(name: string, d?: Descriptor, localize?: boolean) {
+                private enter(name: string, service: string) {
-                    if (trace.isLogEnabled())
-                        trace.log("enter " + name + " " + (d || "") +
-                            (localize ? " localize" : ""));
                     this._stack.push({
                         name,
-                        service: d,
+                        service,
                         scope: this._services
                     });
-                    if (localize)
+                    this._name = name;
                     this._services = Object.create(this._services);
                 }
-                leave() {
+                private leave() {
                     const ctx = this._stack.pop();
                     this._services = ctx.scope;
+                    this._name = ctx.name;
-                    if (trace.isLogEnabled())
-                        trace.log("leave " + ctx.name + " " + (ctx.service || ""));
                 }
             }

src/ts/di/ActivationError.ts +1 -1

             import { ActivationContextInfo } from "./ActivationContext";
             export class ActivationError {
                 activationStack: ActivationContextInfo[];
                 service: string;
                 innerException: any;
                 message: string;
                 constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;
                     this.innerException = innerException;
                 }
                 toString() {
                     const parts = [this.message];
                     if (this.service)
                         parts.push("when activating: " + this.service.toString());
                     if (this.innerException)
                         parts.push("caused by: " + this.innerException.toString());
                     if (this.activationStack) {
                         parts.push("at");
                         this.activationStack
-                            .forEach(x => parts.push(`    ${x.name} ${x.service ? x.service.toString() : ""}`));
+                            .forEach(x => parts.push(`    ${x.name} ${x.service}`));
                     }
                     return parts.join("\n");
                 }
             }

src/ts/di/AggregateDescriptor.ts +23 -10

@@ -1,24 +1,37
1	import { Descriptor } from "./interfaces";	1	import { Descriptor, isDescriptor } from "./interfaces";
2	import { ActivationContext } from "./ActivationContext";	2	import { ActivationContext } from "./ActivationContext";
		3	import { isPrimitive } from "util";
3		4
4	export class AggregateDescriptor implements Descriptor {	5	export class AggregateDescriptor implements Descriptor {
5	_value: object;	6	_value: object;
6		7
7	constructor(value: object) {	8	constructor(value: object) {
8	this._value = value;	9	this._value = value;
9	}	10	}
10		11
11	activate(context: ActivationContext, ~~name~~: ~~string~~) {	12	activate(context: ActivationContext) {
12	context.enter(name);	13	return this._parse(this._value, context, "$value");
13	const v = context.parse(this._value, ".params");
14	context.leave();
15	return v;
16	}	14	}
17		15
18	isInstanceCreated(): boolean {	16	// TODO: make async
19	return false;	17	_parse(value, context: ActivationContext, path: string) {
		18	if (isPrimitive(value))
		19	return value;
		20
		21	if (isDescriptor(value))
		22	return context.activate(value, path);
		23
		24	if (value instanceof Array)
		25	return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
		26
		27	const t = {};
		28	for (const p of Object.keys(value))
		29	t[p] = this._parse(value[p], context, `${path}.${p}`);
		30	return t;
		31
20	}	32	}
21	getInstance(): any {	33
22	throw new Error("Not supported");	34	toString() {
		35	return "@walk";
23	}	36	}
24	}	37	}

src/ts/di/Container.ts +59 -40

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration } from "./interfaces";
+            import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration, DependencyRegistration } from "./interfaces";
             import { AggregateDescriptor } from "./AggregateDescriptor";
-            import { isPrimitive } from "../safe";
+            import { isPrimitive, pmap } from "../safe";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { ModuleResolverBase } from "./ModuleResolverBase";
             import format = require("../text/format");
+            import { throws } from "assert";
             export class Container {
                 _services: ServiceMap;
                 _cache: object;
                 _cleanup: (() => void)[];
                 _root: Container;
                 _parent: Container;
                 _resolver: ModuleResolverBase;
                 constructor(parent?: Container) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this);
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
-                getService(name: string, def?) {
+                resolve(name: string, def?) {
                     const d = this._services[name];
-                    if (!d)
+                    if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
+                    }
-                    if (!isDescriptor(d))
-                        return d;
-                    if (d.isInstanceCreated())
-                        return d.getInstance();
                     const context = new ActivationContext(this, this._services);
                     try {
-                        return d.activate(context, name);
+                        return context.activate(d, name);
                     } catch (error) {
                         throw new ActivationError(name, context.getStack(), error);
                     }
                 }
+                getService(name: string, def?) {
+                    return this.resolve.apply(this, arguments);
+                }
                 register(nameOrCollection, service?) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection;
                         for (const name in data)
                             this.register(name, data[name]);
                     } else {
+                        if (!isDescriptor(service))
+                            throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection] = service;
                     }
                     return this;
                 }
                 onDispose(callback) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     if (this._cleanup) {
                         for (const f of this._cleanup)
                             f();
                         this._cleanup = null;
                     }
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | object, opts?: object) {
                     if (typeof (config) === "string") {
                         const resolver = await this._resolver.createResolver(config, opts);
                         const data = await this._resolver.loadModule(config);
                         return this._configure(data, { resolver });
                     } else {
                         return this._configure(config);
                     }
                 }
                 createChildContainer() {
                     return new Container(this);
                 }
                 has(id) {
                     return id in this._cache;
                 }
                 get(id) {
                     return this._cache[id];
                 }
                 store(id, value) {
                     return (this._cache[id] = value);
                 }
                 async _configure(data: object, opts?: { resolver: ModuleResolverBase }) {
                     const resolver = (opts && opts.resolver) || this._resolver;
-                    const services: ServiceMap = {};
+                    const services = await this._parseRegistrations(data, resolver);
-                    resolver.beginBatch();
-                    async function parse(k) {
-                        services[k] = await this._parse(data[k], resolver);
-                    const batch = Object.keys(data).map(parse);
-                    resolver.completeBatch();
-                    await Promise.all(batch);
                     this.register(services);
                 }
                 async _parse(registration: any, resolver: ModuleResolverBase) {
                     if (isPrimitive(registration) || isDescriptor(registration))
                         return registration;
                     if (isDependencyRegistration(registration)) {
+                        return this._paseReference(registration, resolver);
-                        return new ReferenceDescriptor({
-                            name: registration.$dependency,
-                            lazy: registration.lazy,
-                            optional: registration.optional,
-                            default: registration.default,
-                            services: registration.services && this._parseObject(registration.services, resolver)
-                        });
                     } else if (isValueRegistration(registration)) {
                         return !registration.parse ?
                             new ValueDescriptor(registration.$value) :
                             new AggregateDescriptor(this._parse(registration.$value, resolver));
                     } else if (registration.$type || registration.$factory) {
                         return this._parseService(registration, resolver);
                     } else if (registration instanceof Array) {
                         return this._parseArray(registration, resolver);
                     }
                     return this._parseObject(registration, resolver);
                 }
+                async _paseReference(registration: DependencyRegistration, resolver: ModuleResolverBase) {
+                    return new ReferenceDescriptor({
+                        name: registration.$dependency,
+                        lazy: registration.lazy,
+                        optional: registration.optional,
+                        default: registration.default,
+                        services: registration.services && await this._parseRegistrations(registration.services, resolver)
+                    });
+                }
                 async _parseService(data: ServiceRegistration, resolver: ModuleResolverBase) {
                     const opts: ServiceDescriptorParams = {
                         owner: this
                     };
                     if (data.$type) {
                         if (data.$type instanceof Function)
                             opts.type = data.$type;
                         else if (typeof data.$type === "string")
                             opts.type = await resolver.resolve(data.$type);
                         else
                             throw new Error(format("Unsupported type specification: {0:json}", data.$type));
                     } else {
                         if (data.$factory instanceof Function)
                             opts.factory = data.$factory;
                         else if (typeof data.$factory === "string")
                             opts.factory = await resolver.resolve(data.$factory);
                         else
                             throw new Error(format("Unsupported factory specification: {0:json}", data.$factory));
                     }
                     if (data.services)
-                        opts.services = await this._parseObject(data.services, resolver);
+                        opts.services = await this._parseRegistrations(data.services, resolver);
+                    if (data.inject) {
                         if (data.inject instanceof Array)
                             opts.inject = await Promise.all(data.inject.map(x => this._parseObject(x, resolver)));
                         else
                             opts.inject = [await this._parseObject(data.inject, resolver)];
+                    }
                     if (data.params)
                         opts.params = this._parse(data.params, resolver);
                     if (data.activation) {
                         if (typeof (data.activation) === "string") {
                             switch (data.activation.toLowerCase()) {
                                 case "singleton":
                                     opts.activation = ActivationType.Singleton;
                                     break;
                                 case "container":
                                     opts.activation = ActivationType.Container;
                                     break;
                                 case "hierarchy":
                                     opts.activation = ActivationType.Hierarchy;
                                     break;
                                 case "context":
                                     opts.activation = ActivationType.Context;
                                     break;
                                 case "call":
                                     opts.activation = ActivationType.Call;
                                     break;
                                 default:
                                     throw new Error("Unknown activation type: " +
                                         data.activation);
                             }
                         } else {
                             opts.activation = Number(data.activation);
                         }
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return new ServiceDescriptor(opts);
                 }
-                _parseObject(data: object, resolver: ModuleResolverBase) {
+                async _parseObject(data: object, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     const o = {};
                     for (const p in data)
-                        o[p] = this._parse(data[p], resolver);
+                        o[p] = await this._parse(data[p], resolver);
+                    // TODO: handle inline descriptors properly
+                    // const ex = {
+                    //     activate(ctx) {
+                    //         const value = ctx.activate(this.prop, "prop");
+                    //         // some code
+                    //     },
+                    //     // will be turned to ReferenceDescriptor
+                    //     prop: { $dependency: "depName" }
+                    // };
                     return o;
                 }
-                _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
+                async _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
-                    return data.map(x => this._parse(x, resolver));
+                    return pmap(data, x => this._parse(x, resolver));
+                }
+                async _parseRegistrations(data: object, resolver: ModuleResolverBase) {
+                    if (data.constructor &&
+                        data.constructor.prototype !== Object.prototype)
+                        throw new Error("Registrations must be a simple object");
+                    const o: ServiceMap = {};
+                    for (const p of Object.keys(data)) {
+                        const v = await this._parse(data[p], resolver);
+                        o[p] = isDescriptor(v) ? v : new AggregateDescriptor(v);
+                    }
+                    return o;
                 }
             }

src/ts/di/ReferenceDescriptor.ts +9 -23

             import { isNull, argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { ServiceMap, Descriptor } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams {
                 name: string;
                 lazy?: boolean;
                 optional?: boolean;
                 default?;
                 services?: ServiceMap;
             }
             export class ReferenceDescriptor implements Descriptor {
                 _name: string;
                 _lazy = false;
                 _optional = false;
                 _default: any;
                 _services: ServiceMap;
                 constructor(opts: ReferenceDescriptorParams) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._lazy = !!opts.lazy;
                     this._optional = !!opts.optional;
-                    this._default = !!opts.default;
+                    this._default = opts.default;
                     this._services = opts.services;
                 }
                 activate(context: ActivationContext, name: string) {
-                    if (this._lazy) {
-                        // сохраняем контекст активации
-                        context = context.clone();
                     // добавляем сервисы
                     if (this._services) {
                         for (const p of Object.keys(this._services))
                             context.register(p, this._services[p]);
                     }
+                    if (this._lazy) {
+                        const saved = context.clone();
                         return (cfg: ServiceMap) => {
                             // защищаем контекст на случай исключения в процессе
                             // активации
-                            const ct = context.clone();
+                            const ct = saved.clone();
                             try {
                                 if (cfg) {
                                     for (const k in cfg)
                                         ct.register(k, cfg[k]);
                                 }
-                                return this._optional ? ct.getService(this._name, this._default) : ct
+                                return this._optional ? ct.resolve(this._name, this._default) : ct
-                                    .getService(this._name);
+                                    .resolve(this._name);
                             } catch (error) {
                                 throw new ActivationError(this._name, ct.getStack(), error);
                             }
                         };
                     } else {
-                        context.enter(name, this, !!this._services);
                         // добавляем сервисы
                         if (this._services) {
                             for (const p of Object.keys(this._services))
                                 context.register(p, this._services[p]);
                         }
                         const v = this._optional ?
-                        context.getService(this._name, this._default) :
+                            context.resolve(this._name, this._default) :
-                        context.getService(this._name);
+                            context.resolve(this._name);
-                        context.leave();
                         return v;
                     }
                 }
-                isInstanceCreated() {
-                    return false;
-                getInstance() {
-                    throw new Error("The reference descriptor doesn't allowed to hold an instance");
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     if (this._lazy)
                         opts.push("lazy");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name);
                     if (!isNull(this._default)) {
                         parts.push(" = ");
                         parts.push(this._default);
                     }
                     return parts.join("");
                 }
             }

src/ts/di/ServiceDescriptor.ts +32 -19

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ActivationType, ServiceMap } from "./interfaces";
+            import { Descriptor, ActivationType, ServiceMap, isDescriptor } from "./interfaces";
             import { Container } from "./Container";
             import { argumentNotNull, isPrimitive, oid, isPromise } from "../safe";
             import { Constructor, Factory } from "../interfaces";
+            import { TraceSource } from "../log/TraceSource";
             let cacheId = 0;
+            const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod(target, method, context, args) {
                 const m = target[method];
                 if (!m)
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, context.parse(args, "." + method));
                 else
                     return m.call(target, context.parse(args, "." + method));
             }
             function makeClenupCallback(target, method: ((instance) => void) | string) {
                 if (typeof (method) === "string") {
                     return () => {
                         target[method]();
                     };
                 } else {
                     return () => {
                         method(target);
                     };
                 }
             }
+            // TODO: make async
+            function _parse(value, context: ActivationContext, path: string) {
+                if (isPrimitive(value))
+                    return value;
+                if (isDescriptor(value))
+                    return context.activate(value, path);
+                if (value instanceof Array)
+                    return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
+                const t = {};
+                for (const p of Object.keys(value))
+                    t[p] = this._parse(value[p], context, `${path}.${p}`);
+                return t;
+            }
             export interface ServiceDescriptorParams {
                 activation?: ActivationType;
                 owner: Container;
                 type?: Constructor;
                 factory?: Factory;
                 params?;
                 inject?: object[];
                 services?: ServiceMap;
                 cleanup?: ((x) => void) | string;
             }
             export class ServiceDescriptor implements Descriptor {
                 _instance;
                 _hasInstance = false;
                 _activationType = ActivationType.Call;
                 _services: ServiceMap;
                 _type: Constructor = null;
                 _factory: Factory = null;
                 _params;
                 _inject: object[];
                 _cleanup: ((x) => void) | string;
                 _cacheId: any;
                 _owner: Container;
                 constructor(opts: ServiceDescriptorParams) {
                     argumentNotNull(opts, "opts");
                     argumentNotNull(opts.owner, "owner");
                     this._owner = opts.owner;
                     if (!(opts.type || opts.factory))
                         throw new Error(
                             "Either a type or a factory must be specified");
                     if (opts.activation)
                         this._activationType = opts.activation;
                     if (opts.type)
                         this._type = opts.type;
                     if (opts.params)
                         this._params = opts.params;
                     if (opts.inject)
                         this._inject = opts.inject;
                     if (opts.services)
                         this._services = opts.services;
                     if (opts.factory)
                         this._factory = opts.factory;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = opts.cleanup;
                     }
                     if (this._activationType === ActivationType.Singleton) {
                         const tof = this._type || this._factory;
                         // create the persistent cache identifier for the type
                         if (isPrimitive(tof))
                             this._cacheId = tof;
                         else
                             this._cacheId = oid(tof);
                     } else {
                         this._cacheId = ++cacheId;
                     }
                 }
-                activate(context: ActivationContext, name: string) {
+                activate(context: ActivationContext) {
                     // if we have a local service records, register them first
                     let instance;
                     switch (this._activationType) {
                         case ActivationType.Singleton: // SINGLETON
                             // if the value is cached return it
                             if (this._hasInstance)
                                 return this._instance;
                             // singletons are bound to the root container
                             const container = context.container.getRootContainer();
                             if (container.has(this._cacheId)) {
                                 instance = container.get(this._cacheId);
                             } else {
-                                instance = this._create(context, name);
+                                instance = this._create(context);
                                 container.store(this._cacheId, instance);
                                 if (this._cleanup)
                                     container.onDispose(
                                         makeClenupCallback(instance, this._cleanup));
                             }
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Container: // CONTAINER
                             // return a cached value
                             if (this._hasInstance)
                                 return this._instance;
                             // create an instance
-                            instance = this._create(context, name);
+                            instance = this._create(context);
                             // the instance is bound to the container
                             if (this._cleanup)
                                 this._owner.onDispose(
                                     makeClenupCallback(instance, this._cleanup));
                             // cache and return the instance
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Context: // CONTEXT
                             // return a cached value if one exists
                             if (context.has(this._cacheId))
                                 return context.get(this._cacheId);
                             // context context activated instances are controlled by callers
-                            return context.store(this._cacheId, this._create(
+                            return context.store(this._cacheId, this._create(context));
-                                context,
-                                name));
                         case ActivationType.Call: // CALL
                             // per-call created instances are controlled by callers
-                            return this._create(context, name);
+                            return this._create(context);
                         case ActivationType.Hierarchy: // HIERARCHY
                             // hierarchy activated instances are behave much like container activated
                             // except they are created and bound to the child container
                             // return a cached value
                             if (context.container.has(this._cacheId))
                                 return context.container.get(this._cacheId);
-                            instance = this._create(context, name);
+                            instance = this._create(context);
                             if (this._cleanup)
                                 context.container.onDispose(makeClenupCallback(
                                     instance,
                                     this._cleanup));
                             return context.container.store(this._cacheId, instance);
                         default:
                             throw new Error("Invalid activation type: " + this._activationType);
                     }
                 }
                 isInstanceCreated() {
                     return this._hasInstance;
                 }
                 getInstance() {
                     return this._instance;
                 }
-                _create(context, name) {
+                _create(context: ActivationContext) {
-                    context.enter(name, this, Boolean(this._services));
+                    trace.debug(`constructing ${context._name}`);
                     if (this._activationType !== ActivationType.Call &&
                         context.visit(this._cacheId) > 0)
                         throw new Error("Recursion detected");
                     if (this._services) {
                         for (const p in this._services)
                             context.register(p, this._services[p]);
                     }
                     let instance;
                     if (!this._factory) {
                         const ctor = this._type;
                         if (this._params && this._params.length) {
                             this._factory = (...args) => {
                                 const t = Object.create(ctor.prototype);
                                 const inst = ctor.apply(t, args);
                                 return isPrimitive(inst) ? t : inst;
                             };
                         } else {
                             this._factory = () => {
                                 return new ctor();
                             };
                         }
                     }
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
-                        instance = this._factory.apply(this, context.parse(
+                        instance = this._factory.apply(this, _parse(this._params, context, "args"));
-                            this._params,
-                            ".params"));
                     } else {
-                        instance = this._factory(context.parse(
+                        instance = this._factory(_parse(this._params, context, "args"));
-                            this._params,
-                            ".params"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
-                    context.leave();
                     return instance;
                 }
                 // @constructor {singleton} foo/bar/Baz
                 // @factory {singleton}
                 toString() {
                     const parts = [];
                     parts.push(this._type ? "@constructor" : "@factory");
                     parts.push(ActivationType[this._activationType]);
                     if (typeof (this._type) === "string")
                         parts.push(this._type);
                     return parts.join(" ");
                 }
             }

src/ts/di/ValueDescriptor.ts +5 -11

             import { Descriptor } from "./interfaces";
-            import { ActivationContext } from "./ActivationContext";
             export class ValueDescriptor implements Descriptor {
                 _value;
                 constructor(value) {
                     this._value = value;
                 }
-                activate(context: ActivationContext, name: string) {
+                activate() {
-                    context.enter(name);
-                    const v = this._value;
-                    context.leave();
-                    return v;
-                isInstanceCreated(): boolean {
-                    return true;
-                getInstance() {
                     return this._value;
                 }
+                toString() {
+                    return `@type=${typeof this._value}`;
                 }
+            }

src/ts/di/interfaces.ts +1 -3

             import { isNull, isPrimitive } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Constructor, Factory } from "../interfaces";
             export interface Descriptor {
                 activate(context: ActivationContext, name?: string);
-                isInstanceCreated(): boolean;
-                getInstance();
             }
             export function isDescriptor(x): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
             export interface ServiceMap {
-                [s: string]: any;
+                [s: string]: Descriptor;
             }
             export enum ActivationType {
                 Singleton,
                 Container,
                 Hierarchy,
                 Context,
                 Call
             }
             export interface RegistrationWithServices {
                 services?: object;
             }
             export interface ServiceRegistration extends RegistrationWithServices {
                 $type?: string | Constructor;
                 $factory?: string | Factory;
                 activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
                 params?;
                 inject?: object | object[];
                 cleanup: (instance) => void | string;
             }
             export interface ValueRegistration {
                 $value;
                 parse?: boolean;
             }
             export interface DependencyRegistration extends RegistrationWithServices {
                 $dependency: string;
                 lazy?: boolean;
                 optional?: boolean;
                 default?;
             }
             export function isServiceRegistration(x): x is ServiceRegistration {
                 return (!isPrimitive(x)) && ("$type" in x || "$factory" in x);
             }
             export function isValueRegistration(x): x is ValueRegistration {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration(x): x is DependencyRegistration {
                 return (!isPrimitive(x)) && ("$depdendency" in x);
             }

src/ts/safe.ts +2 -2

             let _nextOid = 0;
-            const _oid = Symbol("__oid");
+            const _oid = typeof Symbol === "function" ? Symbol("__oid") : "__oid";
             export function oid(instance: object): string {
                 if (isNull(instance))
                     return null;
                 if (_oid in instance)
                     return instance[_oid];
                 else
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
             export function argumentNotNull(arg, name) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function argumentNotEmptyString(arg, name) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg, name) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg, type, name) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
             export function isNull(arg) {
                 return (arg === null || arg === undefined);
             }
             export function isPrimitive(arg) {
                 return (arg === null || arg === undefined || typeof (arg) === "string" ||
                     typeof (arg) === "number" || typeof (arg) === "boolean");
             }
             export function isInteger(arg) {
                 return parseInt(arg, 10) === arg;
             }
             export function isNumber(arg) {
                 return parseFloat(arg) === arg;
             }
             export function isString(val) {
                 return typeof (val) === "string" || val instanceof String;
             }
             export function isPromise(val): val is PromiseLike<any> {
                 return "then" in val && val.then instanceof Function;
             }
             export function isNullOrEmptyString(str) {
                 if (str === null || str === undefined ||
                     ((typeof (str) === "string" || str instanceof String) && str.length === 0))
                     return true;
             }
             export function isNotEmptyArray(arg): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
             export function getGlobal() {
                 return this;
             }
             export function get(member: string, context?: object) {
                 argumentNotEmptyString(member, "member");
                 let that = context || getGlobal();
                 const parts = member.split(".");
                 for (const m of parts) {
                     if (!m)
                         continue;
                     if (isNull(that = that[m]))
                         break;
                 }
                 return that;
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
              *          если достигнут конец массива.
              */
             export function each(obj, cb, thisArg?) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     const keys = Object.keys(obj);
                     for (const k of keys) {
                         const x = cb.call(thisArg, obj[k], k);
                         if (x !== undefined)
                             return x;
                     }
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  own properties of the source are entirely copied to the destination.
              *
              */
             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
                 argumentNotNull(dest, "to");
                 const _res = dest as T & S;
                 if (template instanceof Array) {
                     for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
                     const keys = Object.keys(source);
                     for (const p of keys) {
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
                     const keys = Object.keys(source);
                     for (const p of keys)
                         _res[p] = source[p];
                 }
                 return _res;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
             export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
                 if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
                             then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             type _AnyFn = (...args) => any;
             export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                 let method;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
                 return (...args) => {
                     return method.apply(target, args);
                 };
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
              *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
-                if (items && items.then instanceof Function)
+                if (isPromise(items))
                     return items.then(data => pmap(data, cb));
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 const result = [];
                 function next() {
                     let r;
                     let ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
                         if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
             export function first(sequence, cb: (x) => any, err: (x) => any) {
                 if (sequence) {
                     if (isPromise(sequence)) {
                         return sequence.then(res => first(res, cb, err));
                     } else if (sequence && "length" in sequence) {
                         if (sequence.length === 0) {
                             if (err)
                                 return err(new Error("The sequence is empty"));
                             else
                                 throw new Error("The sequence is empty");
                         }
                         return cb ? cb(sequence[0]) : sequence[0];
                     }
                 }
                 if (err)
                     return err(new Error("The sequence is required"));
                 else
                     throw new Error("The sequence is required");
             }
             export function destroy(d) {
                 if (d && "destroy" in d)
                     d.destroy();
             }

test/ts/ContainerTests.ts +52 -4

@@ -1,26 +1,74
1	import { test } from "./TestTraits";	1	import { test, TapeWriter } from "./TestTraits";
2	import { Container } from "@implab/core/di/Container";	2	import { Container } from "@implab/core/di/Container";
3	import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";	3	import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";
4	import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";	4	import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";
		5	import { ValueDescriptor } from "@implab/core/di/ValueDescriptor";
		6	import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
		7	import { Foo } from "./mock/Foo";
		8	import { Bar } from "./mock/Bar";
		9	import { isNull } from "@implab/core/safe";
5		10
6	test("Container register/~~getServic~~e tests", async t => {	11	test("Container register/resolve tests", async t => {
		12	const writer = new TapeWriter(t);
		13
		14	TraceSource.on(ts => {
		15	ts.level = DebugLevel;
		16	writer.writeEvents(ts.events);
		17	});
		18
7	const container = new Container();	19	const container = new Container();
8		20
9	const connection1 = "db://localhost";	21	const connection1 = "db://localhost";
10		22
11	container.register("connection", connection1);	23	container.register("connection", new ValueDescriptor(connection1));
12		24
13	t.equals(container.getService("connection"), connection1);	25	t.equals(container.getService("connection"), connection1);
14		26
15	container.register(	27	container.register(
16	"dbParams",	28	"dbParams",
17	new AggregateDescriptor({	29	new AggregateDescriptor({
18	timeout: 10,	30	timeout: 10,
19	connection: new ReferenceDescriptor({name: "connection"})	31	connection: new ReferenceDescriptor({ name: "connection" })
20	})	32	})
21	);	33	);
22		34
23	const dbParams = container.getService("dbParams");	35	const dbParams = container.getService("dbParams");
24	t.equals(dbParams.connection, connection1);	36	t.equals(dbParams.connection, connection1, "should get connection");
		37
		38	writer.destroy();
		39	});
		40
		41	test("Container configure/resolve tests", async t => {
		42	const writer = new TapeWriter(t);
		43
		44	TraceSource.on(ts => {
		45	ts.level = DebugLevel;
		46	writer.writeEvents(ts.events);
		47	});
		48
		49	const container = new Container();
		50
		51	await container.configure({
		52	foo: {
		53	$type: Foo
		54	},
25		55
		56	bar: {
		57	$type: Bar,
		58	params: {
		59	db: {
		60	provider: {
		61	$dependency: "db"
		62	}
		63	}
		64	}
		65	}
26	});	66	});
		67
		68	const f1 = container.resolve("foo");
		69	t.assert(!isNull(f1), "foo should be not null");
		70
		71	const b1 = container.resolve("bar");
		72
		73	writer.destroy();
		74	});

test/ts/TestTraits.ts +4 0

             import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
             import { Cancellation } from "@implab/core/Cancellation";
             import { TraceEvent, LogLevel, WarnLevel } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
             import { argumentNotNull } from "@implab/core/safe";
             export class TapeWriter implements IDestroyable {
                 readonly _tape: tape.Test;
                 _subscriptions = new Array<IDestroyable>();
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                     this._tape = t;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     const subscription = source.on(this.writeEvent.bind(this));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                     this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
                     if (next.level >= LogLevel) {
                         this._tape.comment("LOG " + next.arg);
                     } else if (next.level >= WarnLevel) {
                         this._tape.comment("WARN " + next.arg);
                     } else {
                         this._tape.comment("ERROR " + next.arg);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(x => x.destroy());
                 }
             }
             export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
                 let un: IDestroyable;
                 try {
                     await new Promise((resolve, reject) => {
                         if (ct.isRequested()) {
                             un = ct.register(reject);
                         } else {
                             const ht = setTimeout(() => {
                                 resolve();
                             }, timeout);
                             un = ct.register(e => {
                                 clearTimeout(ht);
                                 reject(e);
                             });
                         }
                     });
                 } finally {
                     if (un)
                         un.destroy();
                 }
             }
             export function test(name: string, cb: (t: tape.Test) => any) {
                 tape(name, async t => {
                     try {
                         await cb(t);
                     } catch (e) {
+                        // verbose error information
+                        // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
                     }
                 });
             }

tsconfig.json +3 -1

             {
                 "compilerOptions": {
                     "target": "es3",
                     "module": "amd",
                     "sourceMap": true,
                     "outDir" : "build/dist",
                     "declaration": true,
                     "lib": [
-                        "es2015"
+                        "es5",
+                        "es2015.promise",
+                        "es2015.symbol"
                     ]
                 },
                 "include" : [
                     "src/ts/**/*.ts"
                 ]
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages