www.aleph1.co.uk Git - yaffs-website/blob - node_modules/bluebird/js/release/util.js

   1 "use strict";
   2 var es5 = require("./es5");
   3 var canEvaluate = typeof navigator == "undefined";
   4
   5 var errorObj = {e: {}};
   6 var tryCatchTarget;
   7 function tryCatcher() {
   8     try {
   9         var target = tryCatchTarget;
  10         tryCatchTarget = null;
  11         return target.apply(this, arguments);
  12     } catch (e) {
  13         errorObj.e = e;
  14         return errorObj;
  15     }
  16 }
  17 function tryCatch(fn) {
  18     tryCatchTarget = fn;
  19     return tryCatcher;
  20 }
  21
  22 var inherits = function(Child, Parent) {
  23     var hasProp = {}.hasOwnProperty;
  24
  25     function T() {
  26         this.constructor = Child;
  27         this.constructor$ = Parent;
  28         for (var propertyName in Parent.prototype) {
  29             if (hasProp.call(Parent.prototype, propertyName) &&
  30                 propertyName.charAt(propertyName.length-1) !== "$"
  31            ) {
  32                 this[propertyName + "$"] = Parent.prototype[propertyName];
  33             }
  34         }
  35     }
  36     T.prototype = Parent.prototype;
  37     Child.prototype = new T();
  38     return Child.prototype;
  39 };
  40
  41
  42 function isPrimitive(val) {
  43     return val == null || val === true || val === false ||
  44         typeof val === "string" || typeof val === "number";
  45
  46 }
  47
  48 function isObject(value) {
  49     return typeof value === "function" ||
  50            typeof value === "object" && value !== null;
  51 }
  52
  53 function maybeWrapAsError(maybeError) {
  54     if (!isPrimitive(maybeError)) return maybeError;
  55
  56     return new Error(safeToString(maybeError));
  57 }
  58
  59 function withAppended(target, appendee) {
  60     var len = target.length;
  61     var ret = new Array(len + 1);
  62     var i;
  63     for (i = 0; i < len; ++i) {
  64         ret[i] = target[i];
  65     }
  66     ret[i] = appendee;
  67     return ret;
  68 }
  69
  70 function getDataPropertyOrDefault(obj, key, defaultValue) {
  71     if (es5.isES5) {
  72         var desc = Object.getOwnPropertyDescriptor(obj, key);
  73
  74         if (desc != null) {
  75             return desc.get == null && desc.set == null
  76                     ? desc.value
  77                     : defaultValue;
  78         }
  79     } else {
  80         return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
  81     }
  82 }
  83
  84 function notEnumerableProp(obj, name, value) {
  85     if (isPrimitive(obj)) return obj;
  86     var descriptor = {
  87         value: value,
  88         configurable: true,
  89         enumerable: false,
  90         writable: true
  91     };
  92     es5.defineProperty(obj, name, descriptor);
  93     return obj;
  94 }
  95
  96 function thrower(r) {
  97     throw r;
  98 }
  99
 100 var inheritedDataKeys = (function() {
 101     var excludedPrototypes = [
 102         Array.prototype,
 103         Object.prototype,
 104         Function.prototype
 105     ];
 106
 107     var isExcludedProto = function(val) {
 108         for (var i = 0; i < excludedPrototypes.length; ++i) {
 109             if (excludedPrototypes[i] === val) {
 110                 return true;
 111             }
 112         }
 113         return false;
 114     };
 115
 116     if (es5.isES5) {
 117         var getKeys = Object.getOwnPropertyNames;
 118         return function(obj) {
 119             var ret = [];
 120             var visitedKeys = Object.create(null);
 121             while (obj != null && !isExcludedProto(obj)) {
 122                 var keys;
 123                 try {
 124                     keys = getKeys(obj);
 125                 } catch (e) {
 126                     return ret;
 127                 }
 128                 for (var i = 0; i < keys.length; ++i) {
 129                     var key = keys[i];
 130                     if (visitedKeys[key]) continue;
 131                     visitedKeys[key] = true;
 132                     var desc = Object.getOwnPropertyDescriptor(obj, key);
 133                     if (desc != null && desc.get == null && desc.set == null) {
 134                         ret.push(key);
 135                     }
 136                 }
 137                 obj = es5.getPrototypeOf(obj);
 138             }
 139             return ret;
 140         };
 141     } else {
 142         var hasProp = {}.hasOwnProperty;
 143         return function(obj) {
 144             if (isExcludedProto(obj)) return [];
 145             var ret = [];
 146
 147             /*jshint forin:false */
 148             enumeration: for (var key in obj) {
 149                 if (hasProp.call(obj, key)) {
 150                     ret.push(key);
 151                 } else {
 152                     for (var i = 0; i < excludedPrototypes.length; ++i) {
 153                         if (hasProp.call(excludedPrototypes[i], key)) {
 154                             continue enumeration;
 155                         }
 156                     }
 157                     ret.push(key);
 158                 }
 159             }
 160             return ret;
 161         };
 162     }
 163
 164 })();
 165
 166 var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
 167 function isClass(fn) {
 168     try {
 169         if (typeof fn === "function") {
 170             var keys = es5.names(fn.prototype);
 171
 172             var hasMethods = es5.isES5 && keys.length > 1;
 173             var hasMethodsOtherThanConstructor = keys.length > 0 &&
 174                 !(keys.length === 1 && keys[0] === "constructor");
 175             var hasThisAssignmentAndStaticMethods =
 176                 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
 177
 178             if (hasMethods || hasMethodsOtherThanConstructor ||
 179                 hasThisAssignmentAndStaticMethods) {
 180                 return true;
 181             }
 182         }
 183         return false;
 184     } catch (e) {
 185         return false;
 186     }
 187 }
 188
 189 function toFastProperties(obj) {
 190     /*jshint -W027,-W055,-W031*/
 191     function FakeConstructor() {}
 192     FakeConstructor.prototype = obj;
 193     var l = 8;
 194     while (l--) new FakeConstructor();
 195     return obj;
 196     eval(obj);
 197 }
 198
 199 var rident = /^[a-z$_][a-z$_0-9]*$/i;
 200 function isIdentifier(str) {
 201     return rident.test(str);
 202 }
 203
 204 function filledRange(count, prefix, suffix) {
 205     var ret = new Array(count);
 206     for(var i = 0; i < count; ++i) {
 207         ret[i] = prefix + i + suffix;
 208     }
 209     return ret;
 210 }
 211
 212 function safeToString(obj) {
 213     try {
 214         return obj + "";
 215     } catch (e) {
 216         return "[no string representation]";
 217     }
 218 }
 219
 220 function markAsOriginatingFromRejection(e) {
 221     try {
 222         notEnumerableProp(e, "isOperational", true);
 223     }
 224     catch(ignore) {}
 225 }
 226
 227 function originatesFromRejection(e) {
 228     if (e == null) return false;
 229     return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
 230         e["isOperational"] === true);
 231 }
 232
 233 function canAttachTrace(obj) {
 234     return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
 235 }
 236
 237 var ensureErrorObject = (function() {
 238     if (!("stack" in new Error())) {
 239         return function(value) {
 240             if (canAttachTrace(value)) return value;
 241             try {throw new Error(safeToString(value));}
 242             catch(err) {return err;}
 243         };
 244     } else {
 245         return function(value) {
 246             if (canAttachTrace(value)) return value;
 247             return new Error(safeToString(value));
 248         };
 249     }
 250 })();
 251
 252 function classString(obj) {
 253     return {}.toString.call(obj);
 254 }
 255
 256 function copyDescriptors(from, to, filter) {
 257     var keys = es5.names(from);
 258     for (var i = 0; i < keys.length; ++i) {
 259         var key = keys[i];
 260         if (filter(key)) {
 261             try {
 262                 es5.defineProperty(to, key, es5.getDescriptor(from, key));
 263             } catch (ignore) {}
 264         }
 265     }
 266 }
 267
 268 var asArray = function(v) {
 269     if (es5.isArray(v)) {
 270         return v;
 271     }
 272     return null;
 273 };
 274
 275 if (typeof Symbol !== "undefined" && Symbol.iterator) {
 276     var ArrayFrom = typeof Array.from === "function" ? function(v) {
 277         return Array.from(v);
 278     } : function(v) {
 279         var ret = [];
 280         var it = v[Symbol.iterator]();
 281         var itResult;
 282         while (!((itResult = it.next()).done)) {
 283             ret.push(itResult.value);
 284         }
 285         return ret;
 286     };
 287
 288     asArray = function(v) {
 289         if (es5.isArray(v)) {
 290             return v;
 291         } else if (v != null && typeof v[Symbol.iterator] === "function") {
 292             return ArrayFrom(v);
 293         }
 294         return null;
 295     };
 296 }
 297
 298 var isNode = typeof process !== "undefined" &&
 299         classString(process).toLowerCase() === "[object process]";
 300
 301 function env(key, def) {
 302     return isNode ? process.env[key] : def;
 303 }
 304
 305 var ret = {
 306     isClass: isClass,
 307     isIdentifier: isIdentifier,
 308     inheritedDataKeys: inheritedDataKeys,
 309     getDataPropertyOrDefault: getDataPropertyOrDefault,
 310     thrower: thrower,
 311     isArray: es5.isArray,
 312     asArray: asArray,
 313     notEnumerableProp: notEnumerableProp,
 314     isPrimitive: isPrimitive,
 315     isObject: isObject,
 316     canEvaluate: canEvaluate,
 317     errorObj: errorObj,
 318     tryCatch: tryCatch,
 319     inherits: inherits,
 320     withAppended: withAppended,
 321     maybeWrapAsError: maybeWrapAsError,
 322     toFastProperties: toFastProperties,
 323     filledRange: filledRange,
 324     toString: safeToString,
 325     canAttachTrace: canAttachTrace,
 326     ensureErrorObject: ensureErrorObject,
 327     originatesFromRejection: originatesFromRejection,
 328     markAsOriginatingFromRejection: markAsOriginatingFromRejection,
 329     classString: classString,
 330     copyDescriptors: copyDescriptors,
 331     hasDevTools: typeof chrome !== "undefined" && chrome &&
 332                  typeof chrome.loadTimes === "function",
 333     isNode: isNode,
 334     env: env
 335 };
 336 ret.isRecentNode = ret.isNode && (function() {
 337     var version = process.versions.node.split(".").map(Number);
 338     return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
 339 })();
 340
 341 if (ret.isNode) ret.toFastProperties(process);
 342
 343 try {throw new Error(); } catch (e) {ret.lastLineError = e;}
 344 module.exports = ret;