implab/implabjs-core Commit - r65:0c74a0572161

fixed "singleton" activation type handling in container configuration...

cin -

r65:0c74a0572161 v1.2.13 default

parent child

Context file:

r65:0c74a0572161

Collapse all files

src/amd/js/Uri.js +1 -1

-            define(["./declare", "./log/trace!"], function (declare, trace) {
+            define(["dojo/_base/declare", "./log/trace!"], function (declare, trace) {
                 trace.warn("THIS MODULE IS DEPRECATED! use uri-js or similar alternatives.");
                 function parseURI(uri) {
                     var schema, host, port, path, query, hash, i;
                     if (typeof (uri) == "string") {
                         if ((i = uri.indexOf(":")) >= 0 &&
                             uri.substr(0, i).match(/^\w+$/)) {
                             schema = uri.substr(0, i);
                             uri = uri.substr(i + 1);
                         }
                         if (uri.indexOf("//") === 0) {
                             uri = uri.substr(2);
                             if ((i = uri.indexOf("/")) >= 0) {
                                 host = uri.substr(0, i);
                                 uri = uri.substr(i);
                             } else {
                                 host = uri;
                                 uri = "";
                             }
                         }
                         if ((i = uri.indexOf("?")) >= 0) {
                             path = uri.substr(0, i);
                             uri = uri.substr(i + 1);
                         } else {
                             path = uri;
                             uri = "";
                             if ((i = path.indexOf("#")) >= 0) {
                                 hash = path.substr(i + 1);
                                 path = path.substr(0, i);
                             }
                         }
                         if ((i = uri.indexOf("#")) >= 0) {
                             query = uri.substr(0, i);
                             hash = uri.substr(i + 1);
                         } else {
                             query = uri;
                         }
                     }
                     if (host && (i = host.lastIndexOf(":")) >= 0) {
                         port = host.substr(i + 1);
                         host = host.substr(0, i);
                     }
                     return {
                         schema: schema,
                         host: host,
                         port: port,
                         path: path,
                         query: query,
                         hash: hash
                     };
                 }
                 function makeURI(options) {
                     var uri = [];
                     if (options.schema)
                         uri.push(options.schema, ":");
                     if (options.host)
                         uri.push("//", options.host);
                     if (options.host && options.port)
                         uri.push(":", options.port);
                     if (options.path) {
                         if (options.host && options.path[0] != "/")
                             uri.push("/");
                         uri.push(options.path);
                     } else if (options.host) {
                         uri.push("/");
                     }
                     if (options.query)
                         uri.push("?", options.query);
                     if (options.hash)
                         uri.push("#", options.hash);
                     return uri.join("");
                 }
                 function reducePath(parts) {
                     var balance = 0,
                         result = [],
                         isRoot;
                     for (var i = 0; i < parts.length; i++) {
                         var part = parts[i];
                         switch (part) {
                             case "..":
                                 if (balance > 0) {
                                     result.pop();
                                 } else {
                                     if (isRoot)
                                         throw new Error("Unbalanced path: " + parts);
                                     result.push(part);
                                 }
                                 balance--;
                                 break;
                             case ".":
                                 break;
                             case "":
                                 if (i === 0) {
                                     isRoot = true;
                                     result.push(part);
                                 }
                                 break;
                             default:
                                 result.push(part);
                                 balance++;
                                 break;
                         }
                     }
                     return result.join("/");
                 }
                 var meta = {
                     schema: null,
                     host: null,
                     port: null,
                     path: null,
                     query: null,
                     hash: null
                 };
                 var URI = declare(null, {
                     constructor: function (opts) {
                         trace.warn("This class is deprecated use uri-js or similar");
                         if (typeof (opts) == "string")
                             opts = parseURI(opts);
                         for (var p in meta)
                             if (p in opts)
                                 this[p] = opts[p];
                     },
                     clone: function () {
                         return new URI(this);
                     },
                     combine: function (rel) {
                         var me = this;
                         if (typeof (rel) === "string")
                             rel = new URI(rel);
                         else
                             rel = rel.clone();
                         // //some.host:123/path?q=a#123
                         if (rel.host)
                             return rel;
                         // /abs/path?q=a#123
                         if (rel.path && rel.path[0] == "/") {
                             if (me.host) {
                                 rel.schema = me.schema;
                                 rel.host = me.host;
                                 rel.port = me.port;
                             }
                             return rel;
                         }
                         var base = me.clone();
                         // rel/path?a=b#cd
                         if (rel.path) {
                             var segments = base.getSegments();
                             segments.pop();
                             segments.push.apply(segments, rel.getSegments());
                             base.path = reducePath(segments);
                         }
                         // ?q=a#123
                         if (rel.query)
                             base.query = rel.query;
                         if (rel.hash)
                             base.hase = rel.hash;
                         return base;
                     },
                     optimize: function () {
                         this.path = reducePath(this.getSegments());
                     },
                     getSegments: function () {
                         if (typeof (this.path) === "string")
                             return this.path.split("/");
                         else
                             return [];
                     },
                     toString: function () {
                         var uri = [],
                             me = this;
                         if (me.schema)
                             uri.push(me.schema, ":");
                         if (me.host)
                             uri.push("//", me.host);
                         if (me.host && me.port)
                             uri.push(":", me.port);
                         if (me.path) {
                             if (me.host && me.path[0] != "/")
                                 uri.push("/");
                             uri.push(me.path);
                         } else if (me.host) {
                             uri.push("/");
                         }
                         if (me.query)
                             uri.push("?", me.query);
                         if (me.hash)
                             uri.push("#", me.hash);
                         return uri.join("");
                     }
                 });
                 URI.combine = function (base, rel) {
                     if (typeof (base) === "string")
                         base = new URI(base);
                     return base.combine(rel).toString();
                 };
                 return URI;
             });

src/amd/ts/di/ResolverHelper.ts +7 -5

             import { Uuid } from "../Uuid";
-            import { argumentNotEmptyString, getGlobal } from "../safe";
+            import { argumentNotEmptyString, getGlobal, isNullOrEmptyString } from "../safe";
             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import m = require("module");
             const sandboxId = Uuid();
             define(sandboxId, ["require"], r => r);
             // tslint:disable-next-line:no-var-requires
-            const globalRequire = require(sandboxId);
+            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;
                 }
                 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 function makeResolver(moduleName: string, contextRequire: Require) {
+            export async function makeResolver(moduleName: string, contextRequire: Require) {
                 trace.debug(
                     "makeResolver moduleName={0}, contextRequire={1}",
                     moduleName || "<nil>",
                     contextRequire ? typeof (contextRequire) : "<nil>"
                 );
-                const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
+                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/amd/ts/log/trace.ts +4 0

             import { TraceSource } from "./TraceSource";
             import { Predicate } from "../interfaces";
             export = {
+                level: 0,
                 on(filter: any, cb: any) {
                     if (arguments.length === 1) {
                         cb = filter;
                         filter = undefined;
                     }
                     let test: Predicate<string>;
                     if (filter instanceof RegExp) {
                         test = chId => filter.test(chId);
                     } else if (filter instanceof Function) {
                         test = filter;
                     } else if (filter) {
                         test = chId => chId === filter;
                     }
                     if (test) {
                         TraceSource.on(source => {
+                            source.level = this.level;
                             if (test(source.id))
                                 source.events.on(cb);
                         });
                     } else {
                         TraceSource.on(source => {
+                            source.level = this.level;
                             source.events.on(cb);
                         });
                     }
                 },
                 load(id: string, require: any, cb: (trace: TraceSource) => void) {
                     if (id) {
                         cb(TraceSource.get(id));
                     } else if (require.module && require.module.mid) {
                         cb(TraceSource.get(require.module.mid));
                     } else {
                         require(["module"], (module: { id: any; }) => {
                             cb(TraceSource.get(module && module.id));
                         });
                     }
                 },
                 dynamic: true
             };

src/amd/ts/text/TemplateCompiler.ts +2 -2

-            import { format } from "./StringFormat";
+            import * as format from "./format";
             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import { ITemplateParser, TokenType } from "./TemplateParser";
             import m = require("module");
             const trace = TraceSource.get(m.id);
             type TemplateFn = (obj: object) => string;
             export class TemplateCompiler {
                 _data: string[];
                 _code: string[];
                 _wrapWith = true;
                 constructor() {
                     this._code = [];
                     this._data = [];
                 }
                 compile(parser: ITemplateParser): TemplateFn {
                     this.preamble();
                     this.visitTemplate(parser);
                     this.postamble();
                     const text = this._code.join("\n");
                     try {
                         // tslint:disable-next-line:function-constructor
                         const compiled = new Function("obj, format, $data", text);
                         /**
                          * Функция форматирования по шаблону
                          *
                          * @type{Function}
                          * @param{Object} obj объект с параметрами для подстановки
                          */
                         return (obj: object) => compiled(obj || {}, format, this._data);
                     } catch (e) {
                         trace.traceEvent(DebugLevel, [e, text, this._data]);
                         throw e;
                     }
                 }
                 preamble() {
                     this._code.push(
                         "var $p = [];",
                         "var print = function(){",
                         "   $p.push(format.apply(null,arguments));",
                         "};"
                     );
                     if (this._wrapWith)
                         this._code.push("with(obj){");
                 }
                 postamble() {
                     if (this._wrapWith)
                         this._code.push("}");
                     this._code.push("return $p.join('');");
                 }
                 visitTemplate(parser: ITemplateParser) {
                     while (parser.next()) {
                         switch (parser.token()) {
                             case TokenType.OpenBlock:
                                 this.visitCode(parser);
                                 break;
                             case TokenType.OpenInlineBlock:
                                 this.visitInline(parser);
                                 break;
                             default:
                                 this.visitTextFragment(parser);
                                 break;
                         }
                     }
                 }
                 visitInline(parser: ITemplateParser) {
                     const code = ["$p.push("];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     code.push(");");
                     this._code.push(code.join(""));
                 }
                 visitCode(parser: ITemplateParser) {
                     const code = [];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     this._code.push(code.join(""));
                 }
                 visitTextFragment(parser: ITemplateParser) {
-                    const i = this._data.push(parser.value());
+                    const i = this._data.push(parser.value()) - 1;
                     this._code.push("$p.push($data[" + i + "]);");
                 }
             }

src/amd/ts/text/TemplateParser.ts +5 0

             import { argumentNotEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
+            import { TraceSource, DebugLevel } from "../log/TraceSource";
+            import m = require("module");
+            const trace = TraceSource.get(m.id);
             const splitRx = /(<%=|\[%=|<%|\[%|%\]|%>)/;
             export enum TokenType {
                 None,
                 Text,
                 OpenInlineBlock,
                 OpenBlock,
                 CloseBlock
             }
             const tokenMap: MapOf<TokenType> = {
                 "<%": TokenType.OpenBlock,
                 "[%": TokenType.OpenBlock,
                 "<%=": TokenType.OpenInlineBlock,
                 "[%=": TokenType.OpenInlineBlock,
                 "%>": TokenType.CloseBlock,
                 "%]": TokenType.CloseBlock
             };
             export interface ITemplateParser {
                 next(): boolean;
                 token(): TokenType;
                 value(): string;
             }
             export class TemplateParser implements ITemplateParser {
                 _tokens: string[];
                 _pos = -1;
                 _type: TokenType;
                 _value: string;
                 constructor(text: string) {
                     argumentNotEmptyString(text, "text");
                     this._tokens = text.split(splitRx);
                     this._type = TokenType.None;
                 }
                 next() {
                     this._pos++;
                     if (this._pos < this._tokens.length) {
                         this._value = this._tokens[this._pos];
                         this._type = tokenMap[this._value] || TokenType.Text;
                         return true;
                     } else {
                         this._type = TokenType.None;
                         this._value = undefined;
                         return false;
                     }
                 }
                 token() {
                     return this._type;
                 }
                 value() {
                     return this._value;
                 }
             }

src/amd/ts/text/format-compile.ts +2 -1

             import * as module from "module";
             import { TraceSource } from "../log/TraceSource";
+            import { compile } from "./StringFormat";
             const logger = TraceSource.get(module.id);
             logger.warn("The module is deprecated, use StringFormat.compile() method directly");
-            export { compile } from "./StringFormat";
+            export = compile;

src/amd/ts/text/format.ts +24 -4

             import { format as dojoFormatNumber } from "dojo/number";
             import { format as dojoFormatDate } from "dojo/date/locale";
-            import { Formatter } from "./StringFormat";
+            import { Formatter, compile as _compile } from "./StringFormat";
-            import { isNumber } from "../safe";
+            import { isNumber, isNull } from "../safe";
             interface NumberFormatOptions {
                 round?: number;
                 pattern?: string;
             }
             function convertNumber(value: any, pattern: string) {
                 if (isNumber(value)) {
                     const nopt = {} as NumberFormatOptions;
                     if (pattern.indexOf("!") === 0) {
                         nopt.round = -1;
                         pattern = pattern.substr(1);
                     }
                     nopt.pattern = pattern;
                     return dojoFormatNumber(value, nopt);
                 }
             }
             function convertDate(value: any, pattern: string) {
                 if (value instanceof Date) {
                     const m = pattern.match(/^(\w+)-(\w+)$/);
                     if (m)
                         return dojoFormatDate(value, {
                             selector: m[2],
                             formatLength: m[1]
                         });
                     else if (pattern === "iso")
                         return value.toISOString();
                     else
                         return dojoFormatDate(value, {
                             selector: "date",
                             datePattern: pattern
                         });
                 }
             }
             const _formatter = new Formatter([convertNumber, convertDate]);
-            export = function format(msg: string, ...args: any[]) {
+            function format(msg: string, ...args: any[]) {
-                return _formatter.format.apply(msg, ...args);
+                return _formatter.format(msg, ...args);
+            }
+            function _convert(value: any, pattern: string) {
+                return _formatter.convert(value, pattern);
+            }
+            namespace format {
+                export const convert = _convert;
+                export function compile(text: string) {
+                    const template = _compile(text);
+                    return (...data) => {
+                        return template((name, pattern) => {
+                            const value = data[name];
+                            return !isNull(value) ? convert(value, pattern) : "";
+                        });
                     };
+                }
+            }
+            export = format;

src/main/ts/Uuid.ts +11 -8

             // Typescript port of the uuid.js
             //  Copyright (c) 2018 Sergey Smirnov
             //  BSD-2-Clause License https://opensource.org/licenses/BSD-2-Clause
             //
             // uuid.js
             //     Copyright (c) 2010-2012 Robert Kieffer
             //     MIT License - http://opensource.org/licenses/mit-license.php
             declare const window: any;
             declare const require;
             declare const Buffer;
             const _window: any = "undefined" !== typeof window ? window : null;
             // Unique ID creation requires a high quality random # generator. We
             // feature
             // detect to determine the best RNG source, normalizing to a function
             // that
             // returns 128-bits of randomness, since that's what's usually required
             let _rng;
             function setupBrowser() {
                 // Allow for MSIE11 msCrypto
                 const _crypto = _window.crypto || _window.msCrypto;
                 if (!_rng && _crypto && _crypto.getRandomValues) {
                     // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
                     //
                     // Moderately fast, high quality
                     try {
                         const _rnds8 = new Uint8Array(16);
                         _rng = function whatwgRNG() {
                             _crypto.getRandomValues(_rnds8);
                             return _rnds8;
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
                 if (!_rng) {
                     // Math.random()-based (RNG)
                     //
                     // If all else fails, use Math.random(). It's fast, but is of
                     // unspecified
                     // quality.
                     const _rnds = new Array(16);
                     _rng = () => {
                         for (let i = 0, r; i < 16; i++) {
                             if ((i & 0x03) === 0) {
                                 r = Math.random() * 0x100000000;
                             }
                             _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
                         }
                         return _rnds;
                     };
-                    if ("undefined" !== typeof console && console.warn) {
+                    // if ("undefined" !== typeof console && console.warn) {
-                        console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
+                    //    console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
+                    // }
                 }
             }
             function setupNode() {
                 // Node.js crypto-based RNG -
                 // http://nodejs.org/docs/v0.6.2/api/crypto.html
                 //
                 // Moderately fast, high quality
                 if ("function" === typeof require) {
                     try {
                         const _rb = require("crypto").randomBytes;
                         _rng = _rb && (() => _rb(16));
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // Buffer class to use
             const BufferClass = ("function" === typeof Buffer) ? Buffer : Array;
             // Maps for number <-> hex string conversion
             const _byteToHex = [];
             const _hexToByte = {};
             for (let i = 0; i < 256; i++) {
                 _byteToHex[i] = (i + 0x100).toString(16).substr(1);
                 _hexToByte[_byteToHex[i]] = i;
             }
             // **`parse()` - Parse a UUID into it's component bytes**
-            export function _parse(s, buf?, offset?): Array<string> {
+            function _parse(s, buf?, offset?): Array<string> {
                 const i = (buf && offset) || 0; let ii = 0;
                 buf = buf || [];
                 s.toLowerCase().replace(/[0-9a-f]{2}/g, oct => {
                     if (ii < 16) { // Don't overflow!
                         buf[i + ii++] = _hexToByte[oct];
                     }
                 });
                 // Zero out remaining bytes if string was short
                 while (ii < 16) {
                     buf[i + ii++] = 0;
                 }
                 return buf;
             }
             // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
             function _unparse(buf, offset?): string {
                 let i = offset || 0; const bth = _byteToHex;
                 return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" +
                     bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
             }
             // **`v1()` - Generate time-based UUID**
             //
             // Inspired by https://github.com/LiosK/UUID.js
             // and http://docs.python.org/library/uuid.html
             // random #'s we need to init node and clockseq
             const _seedBytes = _rng();
             // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
             // 1)
             const _nodeId = [
                 _seedBytes[0] | 0x01,
                 _seedBytes[1],
                 _seedBytes[2],
                 _seedBytes[3],
                 _seedBytes[4],
                 _seedBytes[5]
             ];
             // Per 4.2.2, randomize (14 bit) clockseq
             let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
             // Previous uuid creation time
             let _lastMSecs = 0; let _lastNSecs = 0;
             // See https://github.com/broofa/node-uuid for API details
-            export function _v1(options?, buf?, offset?): string {
+            function _v1(options?, buf?, offset?): string {
                 let i = buf && offset || 0;
                 const b = buf || [];
                 options = options || {};
                 let clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
                 // UUID timestamps are 100 nano-second units since the Gregorian
                 // epoch,
                 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
                 // time is handled internally as 'msecs' (integer milliseconds) and
                 // 'nsecs'
                 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
                 // 00:00.
                 let msecs = (options.msecs != null) ? options.msecs : new Date()
                     .getTime();
                 // Per 4.2.1.2, use count of uuid's generated during the current
                 // clock
                 // cycle to simulate higher resolution clock
                 let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                 // Time since last uuid creation (in msecs)
                 const dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
                 // Per 4.2.1.2, Bump clockseq on clock regression
                 if (dt < 0 && options.clockseq == null) {
                     clockseq = clockseq + 1 & 0x3fff;
                 }
                 // Reset nsecs if clock regresses (new clockseq) or we've moved onto
                 // a new
                 // time interval
                 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
                     nsecs = 0;
                 }
                 // Per 4.2.1.2 Throw error if too many uuids are requested
                 if (nsecs >= 10000) {
                     throw new Error(
                         "uuid.v1(): Can't create more than 10M uuids/sec");
                 }
                 _lastMSecs = msecs;
                 _lastNSecs = nsecs;
                 _clockseq = clockseq;
                 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
                 msecs += 12219292800000;
                 // `time_low`
                 const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
                 b[i++] = tl >>> 24 & 0xff;
                 b[i++] = tl >>> 16 & 0xff;
                 b[i++] = tl >>> 8 & 0xff;
                 b[i++] = tl & 0xff;
                 // `time_mid`
                 const tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
                 b[i++] = tmh >>> 8 & 0xff;
                 b[i++] = tmh & 0xff;
                 // `time_high_and_version`
                 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
                 b[i++] = tmh >>> 16 & 0xff;
                 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
                 b[i++] = clockseq >>> 8 | 0x80;
                 // `clock_seq_low`
                 b[i++] = clockseq & 0xff;
                 // `node`
                 const node = options.node || _nodeId;
                 for (let n = 0; n < 6; n++) {
                     b[i + n] = node[n];
                 }
                 return buf ? buf : _unparse(b);
             }
             // **`v4()` - Generate random UUID**
             // See https://github.com/broofa/node-uuid for API details
-            export function _v4(options?, buf?, offset?): string {
+            function _v4(options?, buf?, offset?): string {
                 // Deprecated - 'format' argument, as supported in v1.2
                 const i = buf && offset || 0;
                 if (typeof (options) === "string") {
                     buf = (options === "binary") ? new BufferClass(16) : null;
                     options = null;
                 }
                 options = options || {};
                 const rnds = options.random || (options.rng || _rng)();
                 // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
                 rnds[6] = (rnds[6] & 0x0f) | 0x40;
                 rnds[8] = (rnds[8] & 0x3f) | 0x80;
                 // Copy bytes to buffer, if provided
                 if (buf) {
                     for (let ii = 0; ii < 16; ii++) {
                         buf[i + ii] = rnds[ii];
                     }
                 }
                 return buf || _unparse(rnds);
             }
-            export function Uuid() {
+            function _Uuid() {
                 return _v4();
             }
-            export namespace Uuid {
+            namespace _Uuid {
                 export const v4 = _v4;
                 export const v1 = _v1;
                 export const empty = "00000000-0000-0000-0000-000000000000";
                 export const parse = _parse;
+                export const Uuid = _v4;
             }
+            export = _Uuid;

src/main/ts/di/Configuration.ts +7 -28

             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");
-            declare const define;
-            declare const require;
-            declare const module;
-            function hasAmdLoader() {
-                try {
-                    // es6 may throw the exception
-                    return (typeof define === "function" && define.amd);
-                } catch {
-                    return false;
-            function hasNodeJs() {
-                try {
-                    return (typeof module !== "undefined" && module.exports);
-                } catch {
-                    return false;
             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 = makeResolver(null, contextRequire);
+                    const r = await makeResolver(null, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
-                        makeResolver(moduleName, contextRequire),
+                        await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
-                applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
+                async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
-                    return this._applyConfiguration(data, makeResolver(void (0), contextRequire), ct);
+                    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> {
                     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._path.push("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.$type");
+                    argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
-                    opts.factory = opts.$factory;
+                    opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

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

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { Factory } from "../interfaces";
             import { argumentNotNull, oid } from "../safe";
             import { ActivationType } from "./interfaces";
             export interface FactoryServiceDescriptorParams extends ServiceDescriptorParams {
                 factory: Factory;
             }
             export class FactoryServiceDescriptor extends ServiceDescriptor {
                 constructor(opts: FactoryServiceDescriptorParams) {
                     super(opts);
                     argumentNotNull(opts && opts.factory, "opts.factory");
                     // bind to null
-                    this._factory = () => opts.factory();
+                    this._factory = (...args) => opts.factory.apply(null, args);
                     if (opts.activation === ActivationType.Singleton) {
                         this._cacheId = oid(opts.factory);
                     }
                 }
             }

src/main/ts/di/ResolverHelper.d.ts +1 -1

@@ -1,3 +1,3
1	import { ModuleResolver } from "./Configuration";	1	import { ModuleResolver } from "./Configuration";
2		2
3	export declare function makeResolver(moduleName?: string, contextRequire?: any): ModuleResolver; No newline at end of file	3	export declare function makeResolver(moduleName?: string, contextRequire?: any): Promise<ModuleResolver>; No newline at end of file

src/main/ts/di/ServiceDescriptor.ts +4 -4

             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, ActivationType, ServiceMap, isDescriptor } from "./interfaces";
             import { Container } from "./Container";
             import { argumentNotNull, isPrimitive } from "../safe";
             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));
+                    return m.apply(target, _parse(args, context, "." + method));
                 else
-                    return m.call(target, context.parse(args, "." + method));
+                    return m.call(target, _parse(args, context, "." + 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;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
                     return value.map((x, i) => _parse(x, context, `${path}[${i}]`));
                 const t = {};
                 for (const p of Object.keys(value))
                     t[p] = _parse(value[p], context, `${path}.${p}`);
                 return t;
             }
             export interface ServiceDescriptorParams {
                 activation?: ActivationType;
                 owner: Container;
                 params?;
                 inject?: object[];
                 services?: ServiceMap;
                 cleanup?: ((x) => void) | string;
             }
             export class ServiceDescriptor implements Descriptor {
                 _instance;
                 _hasInstance = false;
                 _activationType = ActivationType.Call;
                 _services: ServiceMap;
                 _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.activation)
+                    if ("activation" in opts)
                         this._activationType = opts.activation;
-                    if (opts.params)
+                    if ("params" in opts)
                         this._params = opts.params;
                     if (opts.inject)
                         this._inject = opts.inject;
                     if (opts.services)
                         this._services = opts.services;
                     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;
                     }
                 }
                 activate(context: ActivationContext) {
                     // if we have a local service records, register them first
                     let instance;
                     // ensure we have a cache id
                     if (!this._cacheId)
                         this._cacheId = ++cacheId;
                     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);
                                 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);
                             // 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(context));
                         case ActivationType.Call: // CALL
                             // per-call created instances are controlled by callers
                             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);
                             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;
                 }
                 _factory(...params: any[]): any {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext) {
                     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._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
             }

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

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

src/main/ts/log/TraceSource.ts +7 -1

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
-            import { format } from "../text/StringFormat";
+            import { format as _format } from "../text/StringFormat";
             export const DebugLevel = 400;
             export const LogLevel = 300;
             export const WarnLevel = 200;
             export const ErrorLevel = 100;
             export const SilentLevel = 0;
             export interface TraceEvent {
                 readonly source: TraceSource;
                 readonly level: number;
                 readonly arg: any;
             }
+            function format(msg) {
+                if (typeof(msg) !== "string" || arguments.length === 1)
+                    return msg;
+                return _format.apply(null, arguments);
+            }
             export class TraceSource {
                 readonly id: any;
                 level: number;
                 readonly events: Observable<TraceEvent>;
                 _notifyNext: (arg: TraceEvent) => void;
                 constructor(id: any) {
                     this.id = id || new Object();
                     this.events = new Observable(next => {
                         this._notifyNext = next;
                     });
                 }
                 protected emit(level: number, arg: any) {
                     this._notifyNext({ source: this, level, arg });
                 }
                 isDebugEnabled() {
                     return this.level >= DebugLevel;
                 }
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
                         this.emit(DebugLevel, format.apply(null, arguments));
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
                         this.emit(LogLevel, format.apply(null, arguments));
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
                         this.emit(WarnLevel, format.apply(null, arguments));
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
                         this.emit(ErrorLevel, format.apply(null, arguments));
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
                  * @param arg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, arg: any) {
                     if (this.isEnabled(level))
                         this.emit(level, arg);
                 }
                 /**
                  * Register the specified handler to be called for every new and already
                  * created trace source.
                  *
                  * @param handler the handler which will be called for each trace source
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }

src/main/ts/safe.ts +48 -2

             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) {
                 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;
+                return val && typeof val.then === "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() {
-                return this;
+                // 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();
             }

src/main/ts/text/StringFormat.ts +5 -1

             import { isPrimitive, isNull, each } from "../safe";
             import { MapOf } from "../interfaces";
             type SubstFn = (name: string, format?: string) => string;
             type TemplateFn = (subst: SubstFn) => string;
             type ConvertFn = (value: any, format?: string) => string;
             const map = {
                 "\\{": "&curlopen;",
                 "\\}": "&curlclose;",
                 "&": "&amp;",
                 "\\:": "&colon;"
             };
             const rev = {
                 curlopen: "{",
                 curlclose: "}",
                 amp: "&",
                 colon: ":"
             };
             function espaceString(s: string) {
                 if (!s)
                     return s;
                 return "'" + s.replace(/('|\\)/g, "\\$1").replace("\n", "\\n") + "'";
             }
             function encode(s: string) {
                 if (!s)
                     return s;
                 return s.replace(/\\{|\\}|&|\\:|\n/g, m => map[m] || m);
             }
             function decode(s: string) {
                 if (!s)
                     return s;
                 return s.replace(/&(\w+);/g, (m, $1) => rev[$1] || m);
             }
             function subst(s: string) {
                 const i = s.indexOf(":");
                 let name: string;
                 let pattern: string;
                 if (i >= 0) {
                     name = s.substr(0, i);
                     pattern = s.substr(i + 1);
                 } else {
                     name = s;
                 }
                 if (pattern)
                     return [
                         espaceString(decode(name)),
                         espaceString(decode(pattern))];
                 else
                     return [espaceString(decode(name))];
             }
             function _compile(str: string) {
                 if (!str)
                     return () => void 0;
                 const chunks = encode(str).split("{");
                 let chunk: string;
                 const code = ["var result=[];"];
                 for (let i = 0; i < chunks.length; i++) {
                     chunk = chunks[i];
                     if (i === 0) {
                         if (chunk)
                             code.push("result.push(" + espaceString(decode(chunk)) +
                                 ");");
                     } else {
                         const len = chunk.indexOf("}");
                         if (len < 0)
                             throw new Error("Unbalanced substitution #" + i);
                         code.push("result.push(subst(" +
                             subst(chunk.substr(0, len)).join(",") + "));");
                         if (chunk.length > len + 1)
                             code.push("result.push(" +
                                 espaceString(decode(chunk.substr(len + 1))) + ");");
                     }
                 }
                 code.push("return result.join('');");
                 // the code for this function is generated from the template
                 // tslint:disable-next-line:function-constructor
                 return new Function("subst", code.join("\n")) as TemplateFn;
             }
             const cache: MapOf<TemplateFn> = {};
             export function compile(template: string) {
                 let compiled = cache[template];
                 if (!compiled) {
                     compiled = _compile(template);
                     cache[template] = compiled;
                 }
                 return compiled;
             }
             function defaultConverter(value: any, pattern: string) {
                 if (pattern && pattern.toLocaleLowerCase() === "json") {
                     const seen = [];
                     return JSON.stringify(value, (k, v) => {
                         if (!isPrimitive(v)) {
                             const id = seen.indexOf(v);
                             if (id >= 0)
                                 return "@ref-" + id;
                             else {
                                 seen.push(v);
                                 return v;
                             }
                         } else {
                             return v;
                         }
                     }, 2);
                 } else if (isNull(value)) {
                     return "";
                 } else if (value instanceof Date) {
                     return value.toISOString();
                 } else {
-                    return pattern ? value.toString(pattern) : value.toString();
+                    return value.toString();
                 }
             }
             export class Formatter {
                 _converters: ConvertFn[];
                 constructor(converters?: ConvertFn[]) {
                     this._converters = converters || [];
                     this._converters.push(defaultConverter);
                 }
                 convert(value: any, pattern: string) {
                     for (const c of this._converters) {
                         const res = c(value, pattern);
                         if (!isNull(res))
                             return res;
                     }
                     return "";
                 }
                 format(msg: string, ...args: any[]) {
                     const template = compile(msg);
                     return template((name, pattern) => {
                         const value = args[name];
                         return !isNull(value) ? this.convert(value, pattern) : "";
                     });
                 }
                 compile(msg: string) {
                     const template = compile(msg);
                     return (...args: any[]) => {
                         return template((name, pattern) => {
                             const value = args[name];
                             return !isNull(value) ? this.convert(value, pattern) : "";
                         });
                     };
                 }
             }
             const _default = new Formatter();
             export function format(msg: string, ...args: any[]) {
                 return _default.format(msg, ...args);
             }
+            export function convert(value: any, pattern: string) {
+                return _default.format(value, pattern);
+            }

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