implab/implabjs-core Commit - r71:600f0201c4ba

Minor fixes and improvements...

cin -

r71:600f0201c4ba v1.2.16 default

parent child

Context file:

r71:600f0201c4ba

Collapse all files

history.md +8 0

             HISTORY
             =======
+.2.16
+            ------
+            Minor fixes and improvements
+            - added `isCancellable` type predicate function to `safe` module
+            - `isString, isNumber, isInteger, isPrimitive` are now type predicates
 .2.0
             -----
             Major rafactoring, moving to support both browser (rjs) and server (cjs) environments.
             - dependency injection container ported to typescript
             - sources are split to several sets to provide the ability for the conditional build of the project.
 .0.1
             -----
             First release, intorduces the following features
             - `di` - dependency injection container
             - `log` - log4 style logging system
             - `text` - simple and fast text templating and formatting
             - `Uuid` - uuid generation traits

package-lock.json +6 -6

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "lockfileVersion": 1,
               "requires": true,
               "dependencies": {
                 "@types/node": {
                   "version": "10.12.18",
                   "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz",
                   "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==",
                   "dev": true
                 },
                 "@types/requirejs": {
                   "version": "2.1.31",
                   "resolved": "https://registry.npmjs.org/@types/requirejs/-/requirejs-2.1.31.tgz",
                   "integrity": "sha512-b2soeyuU76rMbcRJ4e0hEl0tbMhFwZeTC0VZnfuWlfGlk6BwWNsev6kFu/twKABPX29wkX84wU2o+cEJoXsiTw==",
                   "dev": true
                 },
                 "@types/tape": {
                   "version": "4.2.33",
                   "resolved": "https://registry.npmjs.org/@types/tape/-/tape-4.2.33.tgz",
                   "integrity": "sha512-ltfyuY5BIkYlGuQfwqzTDT8f0q8Z5DGppvUnWGs39oqDmMd6/UWhNpX3ZMh/VYvfxs3rFGHMrLC/eGRdLiDGuw==",
                   "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.14.2",
                   "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.14.2.tgz",
                   "integrity": "sha512-TI+Ytgfh/VfmHWERp45Jte6NFMdoJTPsvUP/uzJUvAXET8FP2h442LePWWJ/q/xZ4V0V8OtdJhx8It/GB+Zbxg==",
                   "dev": true
                 },
                 "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.13.0",
                   "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz",
                   "integrity": "sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==",
                   "dev": true,
                   "requires": {
                     "es-to-primitive": "^1.2.0",
                     "function-bind": "^1.1.1",
                     "has": "^1.0.3",
                     "is-callable": "^1.1.4",
                     "is-regex": "^1.0.4",
                     "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
                     }
                   }
                 },
                 "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",
+                  "resolved": "https://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",
                   "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": "http://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.2",
                   "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.2.tgz",
                   "integrity": "sha512-lPXKRKILZ1kZaUy5ynWKs8ATGSUO7HAFHCFnBam6FaGSqPdOwMWbxXHq4EXFLE8WRTleo/YOMXkaUTRmTB1Fiw==",
                   "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",
                   "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"
                   }
                 },
                 "tslib": {
                   "version": "1.9.3",
                   "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
                   "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
                   "dev": true
                 },
                 "typescript": {
                   "version": "3.2.2",
                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.2.tgz",
                   "integrity": "sha512-VCj5UiSyHBjwfYacmDuc/NOk4QQixbE+Wn7MFJuS0nRuPQbof132Pw4u53dm264O8LPc2MVsc7RJNml5szurkg==",
                   "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/amd/ts/di/ResolverHelper.ts +5 -38

             import { Uuid } from "../Uuid";
             import { argumentNotEmptyString, getGlobal, isNullOrEmptyString } from "../safe";
-            import { TraceSource, DebugLevel } from "../log/TraceSource";
+            import { TraceSource } from "../log/TraceSource";
             import m = require("module");
             const sandboxId = Uuid();
             define(sandboxId, ["require"], r => r);
             // tslint:disable-next-line:no-var-requires
             const globalRequire = getGlobal().require as Require;
             const trace = TraceSource.get(m.id);
-            export async function createContextRequire(moduleName: string): Promise<Require> {
-                argumentNotEmptyString(moduleName, "moduleName");
-                const parts = moduleName.split("/");
-                if (parts[0] === ".")
-                    throw new Error("An absolute module path is required");
-                if (parts.length > 1)
-                    parts.splice(-1, 1, Uuid());
-                else
-                    parts.push(Uuid());
-                const shim = parts.join("/");
-                trace.debug(`define shim ${shim}`);
-                return new Promise<Require>(cb => {
-                    define(shim, ["require"], r => {
-                        trace.debug("shim resolved");
-                        return r;
-                    });
-                    require([shim], cb);
-                });
             class ModuleResolver {
                 _base: string;
                 _require: Require;
                 constructor(req: Require, base?: string) {
                     this._base = base;
-                    this._require = req || globalRequire;
+                    this._require = req;
                 }
                 resolve(moduleName: string) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     const resolvedName = moduleName[0] === "." && this._base ? [this._base, moduleName].join("/") : moduleName;
                     trace.debug(`${moduleName} -> ${resolvedName}`);
                     const req = this._require;
                     return new Promise<any>((cb, eb) => {
                         req([resolvedName], cb, eb);
                     });
                 }
             }
-            export async function makeResolver(moduleName: string, contextRequire: Require) {
+            export function makeResolver(moduleName: string, contextRequire: Require) {
-                trace.debug(
+                const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
-                    "makeResolver moduleName={0}, contextRequire={1}",
-                    moduleName || "<nil>",
-                    contextRequire ? typeof (contextRequire) : "<nil>"
-                );
-                const nestedRequire = isNullOrEmptyString(moduleName) ? null : await createContextRequire(moduleName);
+                const resolver = new ModuleResolver(contextRequire, base);
-                // const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
-                const resolver = new ModuleResolver(nestedRequire, null);
                 return (id: string) => resolver.resolve(id);
             }

src/main/ts/di/Configuration.ts +1 -1

             import {
                 ServiceRegistration,
                 TypeRegistration,
                 FactoryRegistration,
                 ServiceMap,
                 isDescriptor,
                 isDependencyRegistration,
                 DependencyRegistration,
                 ValueRegistration,
                 ActivationType,
                 isValueRegistration,
                 isTypeRegistration,
                 isFactoryRegistration
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: object | any[], map?: (v, k) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             type _key = string | number;
             export class Configuration {
                 _hasInnerDescriptors = false;
                 _container: Container;
                 _path: Array<_key>;
                 _configName: string;
                 _require: ModuleResolver;
                 constructor(container: Container) {
                     argumentNotNull(container, container);
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(null, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: object, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: ServiceMap;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName;
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
                         return localName ? get(localName, m) : m;
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data, name: _key) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const o: ServiceMap = {};
                     const keys = Object.keys(data);
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k);
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as ServiceMap;
                     this._leave();
                     return services;
                 }
                 _enter(name: _key) {
                     this._path.push(name);
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
-                _visit(data, name: string): Promise<any> {
+                async _visit(data, name: string) {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: object, name: _key) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // 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" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: _key) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration) {
                     const opts: any = {
                         owner: this._container
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     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 opts;
                 }
                 async _visitValueRegistration(data: ValueRegistration, name: _key) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration(data: DependencyRegistration, name: _key) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const d = new ReferenceDescriptor({
                         name: data.$dependency,
                         lazy: data.lazy,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     });
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration, name: _key) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
                         opts.type = this._resolveType(moduleName, typeName);
                     }
                     const d = new TypeServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration, name: _key) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/safe.ts +10 -4

+            import { ICancellable } from "./interfaces";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
             declare const window: any;
             declare const global: any;
             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) {
+            export function isPrimitive(arg): arg is string | number | boolean | undefined | null {
                 return (arg === null || arg === undefined || typeof (arg) === "string" ||
                     typeof (arg) === "number" || typeof (arg) === "boolean");
             }
-            export function isInteger(arg) {
+            export function isInteger(arg): arg is number {
                 return parseInt(arg, 10) === arg;
             }
-            export function isNumber(arg) {
+            export function isNumber(arg): arg is number {
                 return parseFloat(arg) === arg;
             }
-            export function isString(val) {
+            export function isString(val): val is string {
                 return typeof (val) === "string" || val instanceof String;
             }
             export function isPromise(val): val is PromiseLike<any> {
                 return val && typeof val.then === "function";
             }
+            export function isCancellable(val): val is ICancellable {
+                return val && typeof val.cancel === "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);
             }
             function _isStrictMode() {
                 return !this;
             }
             function _getNonStrictGlobal() {
                 return this;
             }
             export function getGlobal() {
                 // in es3 we can't use indirect call to eval, since it will
                 // be executed in the current call context.
                 if (!_isStrictMode()) {
                     return _getNonStrictGlobal();
                 } else {
                     // tslint:disable-next-line:no-eval
                     return eval.call(null, "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 (isPrimitive(source))
                     return _res;
                 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 (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();
             }
             export function pfor(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => {
                         return pmap(data, cb);
                     });
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 function next() {
                     while (i < items.length) {
                         const r = cb(items[i], i);
                         i++;
                         if (isPromise(r))
                             return r.then(next);
                     }
                 }
                 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();
             }

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