vnfmarket/src/main/webapp/vnfmarket/node_modules/levn/lib/coerce.js

   1 // Generated by LiveScript 1.2.0
   2 (function(){
   3   var parsedTypeCheck, types, toString$ = {}.toString;
   4   parsedTypeCheck = require('type-check').parsedTypeCheck;
   5   types = {
   6     '*': function(it){
   7       switch (toString$.call(it).slice(8, -1)) {
   8       case 'Array':
   9         return coerceType(it, {
  10           type: 'Array'
  11         });
  12       case 'Object':
  13         return coerceType(it, {
  14           type: 'Object'
  15         });
  16       default:
  17         return {
  18           type: 'Just',
  19           value: coerceTypes(it, [
  20             {
  21               type: 'Undefined'
  22             }, {
  23               type: 'Null'
  24             }, {
  25               type: 'NaN'
  26             }, {
  27               type: 'Boolean'
  28             }, {
  29               type: 'Number'
  30             }, {
  31               type: 'Date'
  32             }, {
  33               type: 'RegExp'
  34             }, {
  35               type: 'Array'
  36             }, {
  37               type: 'Object'
  38             }, {
  39               type: 'String'
  40             }
  41           ], {
  42             explicit: true
  43           })
  44         };
  45       }
  46     },
  47     Undefined: function(it){
  48       if (it === 'undefined' || it === void 8) {
  49         return {
  50           type: 'Just',
  51           value: void 8
  52         };
  53       } else {
  54         return {
  55           type: 'Nothing'
  56         };
  57       }
  58     },
  59     Null: function(it){
  60       if (it === 'null') {
  61         return {
  62           type: 'Just',
  63           value: null
  64         };
  65       } else {
  66         return {
  67           type: 'Nothing'
  68         };
  69       }
  70     },
  71     NaN: function(it){
  72       if (it === 'NaN') {
  73         return {
  74           type: 'Just',
  75           value: NaN
  76         };
  77       } else {
  78         return {
  79           type: 'Nothing'
  80         };
  81       }
  82     },
  83     Boolean: function(it){
  84       if (it === 'true') {
  85         return {
  86           type: 'Just',
  87           value: true
  88         };
  89       } else if (it === 'false') {
  90         return {
  91           type: 'Just',
  92           value: false
  93         };
  94       } else {
  95         return {
  96           type: 'Nothing'
  97         };
  98       }
  99     },
 100     Number: function(it){
 101       return {
 102         type: 'Just',
 103         value: +it
 104       };
 105     },
 106     Int: function(it){
 107       return {
 108         type: 'Just',
 109         value: parseInt(it)
 110       };
 111     },
 112     Float: function(it){
 113       return {
 114         type: 'Just',
 115         value: parseFloat(it)
 116       };
 117     },
 118     Date: function(value, options){
 119       var that;
 120       if (that = /^\#(.*)\#$/.exec(value)) {
 121         return {
 122           type: 'Just',
 123           value: new Date(+that[1] || that[1])
 124         };
 125       } else if (options.explicit) {
 126         return {
 127           type: 'Nothing'
 128         };
 129       } else {
 130         return {
 131           type: 'Just',
 132           value: new Date(+value || value)
 133         };
 134       }
 135     },
 136     RegExp: function(value, options){
 137       var that;
 138       if (that = /^\/(.*)\/([gimy]*)$/.exec(value)) {
 139         return {
 140           type: 'Just',
 141           value: new RegExp(that[1], that[2])
 142         };
 143       } else if (options.explicit) {
 144         return {
 145           type: 'Nothing'
 146         };
 147       } else {
 148         return {
 149           type: 'Just',
 150           value: new RegExp(value)
 151         };
 152       }
 153     },
 154     Array: function(it){
 155       return coerceArray(it, {
 156         of: [{
 157           type: '*'
 158         }]
 159       });
 160     },
 161     Object: function(it){
 162       return coerceFields(it, {
 163         of: {}
 164       });
 165     },
 166     String: function(it){
 167       var that;
 168       if (toString$.call(it).slice(8, -1) !== 'String') {
 169         return {
 170           type: 'Nothing'
 171         };
 172       }
 173       if (that = it.match(/^'(.*)'$/)) {
 174         return {
 175           type: 'Just',
 176           value: that[1]
 177         };
 178       } else if (that = it.match(/^"(.*)"$/)) {
 179         return {
 180           type: 'Just',
 181           value: that[1]
 182         };
 183       } else {
 184         return {
 185           type: 'Just',
 186           value: it
 187         };
 188       }
 189     }
 190   };
 191   function coerceArray(node, type){
 192     var typeOf, element;
 193     if (toString$.call(node).slice(8, -1) !== 'Array') {
 194       return {
 195         type: 'Nothing'
 196       };
 197     }
 198     typeOf = type.of;
 199     return {
 200       type: 'Just',
 201       value: (function(){
 202         var i$, ref$, len$, results$ = [];
 203         for (i$ = 0, len$ = (ref$ = node).length; i$ < len$; ++i$) {
 204           element = ref$[i$];
 205           results$.push(coerceTypes(element, typeOf));
 206         }
 207         return results$;
 208       }())
 209     };
 210   }
 211   function coerceTuple(node, type){
 212     var result, i$, ref$, len$, i, types, that;
 213     if (toString$.call(node).slice(8, -1) !== 'Array') {
 214       return {
 215         type: 'Nothing'
 216       };
 217     }
 218     result = [];
 219     for (i$ = 0, len$ = (ref$ = type.of).length; i$ < len$; ++i$) {
 220       i = i$;
 221       types = ref$[i$];
 222       if (that = coerceTypes(node[i], types)) {
 223         result.push(that);
 224       }
 225     }
 226     return {
 227       type: 'Just',
 228       value: result
 229     };
 230   }
 231   function coerceFields(node, type){
 232     var typeOf, key, value;
 233     if (toString$.call(node).slice(8, -1) !== 'Object') {
 234       return {
 235         type: 'Nothing'
 236       };
 237     }
 238     typeOf = type.of;
 239     return {
 240       type: 'Just',
 241       value: (function(){
 242         var ref$, results$ = {};
 243         for (key in ref$ = node) {
 244           value = ref$[key];
 245           results$[key] = coerceTypes(value, typeOf[key] || [{
 246             type: '*'
 247           }]);
 248         }
 249         return results$;
 250       }())
 251     };
 252   }
 253   function coerceType(node, typeObj, options){
 254     var type, structure, coerceFunc;
 255     type = typeObj.type, structure = typeObj.structure;
 256     if (type) {
 257       coerceFunc = types[type];
 258       return coerceFunc(node, options);
 259     } else {
 260       switch (structure) {
 261       case 'array':
 262         return coerceArray(node, typeObj);
 263       case 'tuple':
 264         return coerceTuple(node, typeObj);
 265       case 'fields':
 266         return coerceFields(node, typeObj);
 267       }
 268     }
 269   }
 270   function coerceTypes(node, types, options){
 271     var i$, len$, type, ref$, valueType, value;
 272     for (i$ = 0, len$ = types.length; i$ < len$; ++i$) {
 273       type = types[i$];
 274       ref$ = coerceType(node, type, options), valueType = ref$.type, value = ref$.value;
 275       if (valueType === 'Nothing') {
 276         continue;
 277       }
 278       if (parsedTypeCheck([type], value)) {
 279         return value;
 280       }
 281     }
 282     throw new Error("Value " + JSON.stringify(node) + " does not type check against " + JSON.stringify(types) + ".");
 283   }
 284   module.exports = coerceTypes;
 285 }).call(this);