Source/Core/Core.js

   1 /*
   2 ---
   3
   4 name: Core
   5
   6 description: The heart of MooTools.
   7
   8 license: MIT-style license.
   9
  10 copyright: Copyright (c) 2006-2015 [Valerio Proietti](http://mad4milk.net/).
  11
  12 authors: The MooTools production team (http://mootools.net/developers/)
  13
  14 inspiration:
  15   - Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
  16   - Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)
  17
  18 provides: [Core, MooTools, Type, typeOf, instanceOf, Native]
  19
  20 ...
  21 */
  22 /*! MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2015 [Valerio Proietti](http://mad4milk.net/).*/
  23 (function(){
  24
  25 this.MooTools = {
  26         version: '1.6.1-dev',
  27         build: '%build%'
  28 };
  29
  30 // typeOf, instanceOf
  31
  32 var typeOf = this.typeOf = function(item){
  33         if (item == null) return 'null';
  34         if (item.$family != null) return item.$family();
  35
  36         if (item.nodeName){
  37                 if (item.nodeType == 1) return 'element';
  38                 if (item.nodeType == 3) return (/\S/).test(item.nodeValue) ? 'textnode' : 'whitespace';
  39         } else if (typeof item.length == 'number'){
  40                 if ('callee' in item) return 'arguments';
  41                 if ('item' in item) return 'collection';
  42         }
  43
  44         return typeof item;
  45 };
  46
  47 var instanceOf = this.instanceOf = function(item, object){
  48         if (item == null) return false;
  49         var constructor = item.$constructor || item.constructor;
  50         while (constructor){
  51                 if (constructor === object) return true;
  52                 constructor = constructor.parent;
  53         }
  54         /*<ltIE8>*/
  55         if (!item.hasOwnProperty) return false;
  56         /*</ltIE8>*/
  57         return item instanceof object;
  58 };
  59
  60 var hasOwnProperty = Object.prototype.hasOwnProperty;
  61
  62 /*<ltIE8>*/
  63 var enumerables = true;
  64 for (var i in {toString: 1}) enumerables = null;
  65 if (enumerables) enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
  66 function forEachObjectEnumberableKey(object, fn, bind){
  67         if (enumerables) for (var i = enumerables.length; i--;){
  68                 var k = enumerables[i];
  69                 // signature has key-value, so overloadSetter can directly pass the
  70                 // method function, without swapping arguments.
  71                 if (hasOwnProperty.call(object, k)) fn.call(bind, k, object[k]);
  72         }
  73 }
  74 /*</ltIE8>*/
  75
  76 // Function overloading
  77
  78 var Function = this.Function;
  79
  80 Function.prototype.overloadSetter = function(usePlural){
  81         var self = this;
  82         return function(a, b){
  83                 if (a == null) return this;
  84                 if (usePlural || typeof a != 'string'){
  85                         for (var k in a) self.call(this, k, a[k]);
  86                         /*<ltIE8>*/
  87                         forEachObjectEnumberableKey(a, self, this);
  88                         /*</ltIE8>*/
  89                 } else {
  90                         self.call(this, a, b);
  91                 }
  92                 return this;
  93         };
  94 };
  95
  96 Function.prototype.overloadGetter = function(usePlural){
  97         var self = this;
  98         return function(a){
  99                 var args, result;
 100                 if (typeof a != 'string') args = a;
 101                 else if (arguments.length > 1) args = arguments;
 102                 else if (usePlural) args = [a];
 103                 if (args){
 104                         result = {};
 105                         for (var i = 0; i < args.length; i++) result[args[i]] = self.call(this, args[i]);
 106                 } else {
 107                         result = self.call(this, a);
 108                 }
 109                 return result;
 110         };
 111 };
 112
 113 Function.prototype.extend = function(key, value){
 114         this[key] = value;
 115 }.overloadSetter();
 116
 117 Function.prototype.implement = function(key, value){
 118         this.prototype[key] = value;
 119 }.overloadSetter();
 120
 121 // From
 122
 123 var slice = Array.prototype.slice;
 124
 125 Array.convert = function(item){
 126         if (item == null) return [];
 127         return (Type.isEnumerable(item) && typeof item != 'string') ? (typeOf(item) == 'array') ? item : slice.call(item) : [item];
 128 };
 129
 130 Function.convert = function(item){
 131         return (typeOf(item) == 'function') ? item : function(){
 132                 return item;
 133         };
 134 };
 135
 136
 137 Number.convert = function(item){
 138         var number = parseFloat(item);
 139         return isFinite(number) ? number : null;
 140 };
 141
 142 String.convert = function(item){
 143         return item + '';
 144 };
 145
 146 /*<1.5compat>*/
 147 Array.from = Array.convert;
 148 /*</1.5compat>*/
 149
 150 Function.from = Function.convert;
 151 Number.from = Number.convert;
 152 String.from = String.convert;
 153
 154 // hide, protect
 155
 156 Function.implement({
 157
 158         hide: function(){
 159                 this.$hidden = true;
 160                 return this;
 161         },
 162
 163         protect: function(){
 164                 this.$protected = true;
 165                 return this;
 166         }
 167
 168 });
 169
 170 // Type
 171
 172 var Type = this.Type = function(name, object){
 173         if (name){
 174                 var lower = name.toLowerCase();
 175                 var typeCheck = function(item){
 176                         return (typeOf(item) == lower);
 177                 };
 178
 179                 Type['is' + name] = typeCheck;
 180                 if (object != null){
 181                         object.prototype.$family = (function(){
 182                                 return lower;
 183                         }).hide();
 184                         //<1.2compat>
 185                         object.type = typeCheck;
 186                         //</1.2compat>
 187                 }
 188         }
 189
 190         if (object == null) return null;
 191
 192         object.extend(this);
 193         object.$constructor = Type;
 194         object.prototype.$constructor = object;
 195
 196         return object;
 197 };
 198
 199 var toString = Object.prototype.toString;
 200
 201 Type.isEnumerable = function(item){
 202         return (item != null && typeof item.length == 'number' && toString.call(item) != '[object Function]' );
 203 };
 204
 205 var hooks = {};
 206
 207 var hooksOf = function(object){
 208         var type = typeOf(object.prototype);
 209         return hooks[type] || (hooks[type] = []);
 210 };
 211
 212 var implement = function(name, method){
 213         if (method && method.$hidden) return;
 214
 215         var hooks = hooksOf(this);
 216
 217         for (var i = 0; i < hooks.length; i++){
 218                 var hook = hooks[i];
 219                 if (typeOf(hook) == 'type') implement.call(hook, name, method);
 220                 else hook.call(this, name, method);
 221         }
 222
 223         var previous = this.prototype[name];
 224         if (previous == null || !previous.$protected) this.prototype[name] = method;
 225
 226         if (this[name] == null && typeOf(method) == 'function') extend.call(this, name, function(item){
 227                 return method.apply(item, slice.call(arguments, 1));
 228         });
 229 };
 230
 231 var extend = function(name, method){
 232         if (method && method.$hidden) return;
 233         var previous = this[name];
 234         if (previous == null || !previous.$protected) this[name] = method;
 235 };
 236
 237 Type.implement({
 238
 239         implement: implement.overloadSetter(),
 240
 241         extend: extend.overloadSetter(),
 242
 243         alias: function(name, existing){
 244                 implement.call(this, name, this.prototype[existing]);
 245         }.overloadSetter(),
 246
 247         mirror: function(hook){
 248                 hooksOf(this).push(hook);
 249                 return this;
 250         }
 251
 252 });
 253
 254 new Type('Type', Type);
 255
 256 // Default Types
 257
 258 var force = function(name, object, methods){
 259         var isType = (object != Object),
 260                 prototype = object.prototype;
 261
 262         if (isType) object = new Type(name, object);
 263
 264         for (var i = 0, l = methods.length; i < l; i++){
 265                 var key = methods[i],
 266                         generic = object[key],
 267                         proto = prototype[key];
 268
 269                 if (generic) generic.protect();
 270                 if (isType && proto) object.implement(key, proto.protect());
 271         }
 272
 273         if (isType){
 274                 var methodsEnumerable = prototype.propertyIsEnumerable(methods[0]);
 275                 object.forEachMethod = function(fn){
 276                         if (!methodsEnumerable) for (var i = 0, l = methods.length; i < l; i++){
 277                                 fn.call(prototype, prototype[methods[i]], methods[i]);
 278                         }
 279                         for (var key in prototype) fn.call(prototype, prototype[key], key);
 280                 };
 281         }
 282
 283         return force;
 284 };
 285
 286 force('String', String, [
 287         'charAt', 'charCodeAt', 'concat', 'contains', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search',
 288         'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'
 289 ])('Array', Array, [
 290         'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice',
 291         'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight', 'contains'
 292 ])('Number', Number, [
 293         'toExponential', 'toFixed', 'toLocaleString', 'toPrecision'
 294 ])('Function', Function, [
 295         'apply', 'call', 'bind'
 296 ])('RegExp', RegExp, [
 297         'exec', 'test'
 298 ])('Object', Object, [
 299         'create', 'defineProperty', 'defineProperties', 'keys',
 300         'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames',
 301         'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'
 302 ])('Date', Date, ['now']);
 303
 304 Object.extend = extend.overloadSetter();
 305
 306 Date.extend('now', function(){
 307         return +(new Date);
 308 });
 309
 310 new Type('Boolean', Boolean);
 311
 312 // fixes NaN returning as Number
 313
 314 Number.prototype.$family = function(){
 315         return isFinite(this) ? 'number' : 'null';
 316 }.hide();
 317
 318 // Number.random
 319
 320 Number.extend('random', function(min, max){
 321         return Math.floor(Math.random() * (max - min + 1) + min);
 322 });
 323
 324 // forEach, each, keys
 325
 326 Array.implement({
 327
 328         /*<!ES5>*/
 329         forEach: function(fn, bind){
 330                 for (var i = 0, l = this.length; i < l; i++){
 331                         if (i in this) fn.call(bind, this[i], i, this);
 332                 }
 333         },
 334         /*</!ES5>*/
 335
 336         each: function(fn, bind){
 337                 Array.forEach(this, fn, bind);
 338                 return this;
 339         }
 340
 341 });
 342
 343 Object.extend({
 344
 345         keys: function(object){
 346                 var keys = [];
 347                 for (var k in object){
 348                         if (hasOwnProperty.call(object, k)) keys.push(k);
 349                 }
 350                 /*<ltIE8>*/
 351                 forEachObjectEnumberableKey(object, function(k){
 352                         keys.push(k);
 353                 });
 354                 /*</ltIE8>*/
 355                 return keys;
 356         },
 357
 358         forEach: function(object, fn, bind){
 359                 Object.keys(object).forEach(function(key){
 360                         fn.call(bind, object[key], key, object);
 361                 });
 362         }
 363
 364 });
 365
 366 Object.each = Object.forEach;
 367
 368
 369 // Array & Object cloning, Object merging and appending
 370
 371 var cloneOf = function(item){
 372         switch (typeOf(item)){
 373                 case 'array': return item.clone();
 374                 case 'object': return Object.clone(item);
 375                 default: return item;
 376         }
 377 };
 378
 379 Array.implement('clone', function(){
 380         var i = this.length, clone = new Array(i);
 381         while (i--) clone[i] = cloneOf(this[i]);
 382         return clone;
 383 });
 384
 385 var mergeOne = function(source, key, current){
 386         switch (typeOf(current)){
 387                 case 'object':
 388                         if (typeOf(source[key]) == 'object') Object.merge(source[key], current);
 389                         else source[key] = Object.clone(current);
 390                         break;
 391                 case 'array': source[key] = current.clone(); break;
 392                 default: source[key] = current;
 393         }
 394         return source;
 395 };
 396
 397 Object.extend({
 398
 399         merge: function(source, k, v){
 400                 if (typeOf(k) == 'string') return mergeOne(source, k, v);
 401                 for (var i = 1, l = arguments.length; i < l; i++){
 402                         var object = arguments[i];
 403                         for (var key in object) mergeOne(source, key, object[key]);
 404                 }
 405                 return source;
 406         },
 407
 408         clone: function(object){
 409                 var clone = {};
 410                 for (var key in object) clone[key] = cloneOf(object[key]);
 411                 return clone;
 412         },
 413
 414         append: function(original){
 415                 for (var i = 1, l = arguments.length; i < l; i++){
 416                         var extended = arguments[i] || {};
 417                         for (var key in extended) original[key] = extended[key];
 418                 }
 419                 return original;
 420         }
 421
 422 });
 423
 424 // Object-less types
 425
 426 ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each(function(name){
 427         new Type(name);
 428 });
 429
 430 // Unique ID
 431
 432 var UID = Date.now();
 433
 434 String.extend('uniqueID', function(){
 435         return (UID++).toString(36);
 436 });
 437
 438 //<1.2compat>
 439
 440 var Hash = this.Hash = new Type('Hash', function(object){
 441         if (typeOf(object) == 'hash') object = Object.clone(object.getClean());
 442         for (var key in object) this[key] = object[key];
 443         return this;
 444 });
 445
 446 Hash.implement({
 447
 448         forEach: function(fn, bind){
 449                 Object.forEach(this, fn, bind);
 450         },
 451
 452         getClean: function(){
 453                 var clean = {};
 454                 for (var key in this){
 455                         if (this.hasOwnProperty(key)) clean[key] = this[key];
 456                 }
 457                 return clean;
 458         },
 459
 460         getLength: function(){
 461                 var length = 0;
 462                 for (var key in this){
 463                         if (this.hasOwnProperty(key)) length++;
 464                 }
 465                 return length;
 466         }
 467
 468 });
 469
 470 Hash.alias('each', 'forEach');
 471
 472 Object.type = Type.isObject;
 473
 474 var Native = this.Native = function(properties){
 475         return new Type(properties.name, properties.initialize);
 476 };
 477
 478 Native.type = Type.type;
 479
 480 Native.implement = function(objects, methods){
 481         for (var i = 0; i < objects.length; i++) objects[i].implement(methods);
 482         return Native;
 483 };
 484
 485 var arrayType = Array.type;
 486 Array.type = function(item){
 487         return instanceOf(item, Array) || arrayType(item);
 488 };
 489
 490 this.$A = function(item){
 491         return Array.convert(item).slice();
 492 };
 493
 494 this.$arguments = function(i){
 495         return function(){
 496                 return arguments[i];
 497         };
 498 };
 499
 500 this.$chk = function(obj){
 501         return !!(obj || obj === 0);
 502 };
 503
 504 this.$clear = function(timer){
 505         clearTimeout(timer);
 506         clearInterval(timer);
 507         return null;
 508 };
 509
 510 this.$defined = function(obj){
 511         return (obj != null);
 512 };
 513
 514 this.$each = function(iterable, fn, bind){
 515         var type = typeOf(iterable);
 516         ((type == 'arguments' || type == 'collection' || type == 'array' || type == 'elements') ? Array : Object).each(iterable, fn, bind);
 517 };
 518
 519 this.$empty = function(){};
 520
 521 this.$extend = function(original, extended){
 522         return Object.append(original, extended);
 523 };
 524
 525 this.$H = function(object){
 526         return new Hash(object);
 527 };
 528
 529 this.$merge = function(){
 530         var args = Array.slice(arguments);
 531         args.unshift({});
 532         return Object.merge.apply(null, args);
 533 };
 534
 535 this.$lambda = Function.convert;
 536 this.$mixin = Object.merge;
 537 this.$random = Number.random;
 538 this.$splat = Array.convert;
 539 this.$time = Date.now;
 540
 541 this.$type = function(object){
 542         var type = typeOf(object);
 543         if (type == 'elements') return 'array';
 544         return (type == 'null') ? false : type;
 545 };
 546
 547 this.$unlink = function(object){
 548         switch (typeOf(object)){
 549                 case 'object': return Object.clone(object);
 550                 case 'array': return Array.clone(object);
 551                 case 'hash': return new Hash(object);
 552                 default: return object;
 553         }
 554 };
 555
 556 //</1.2compat>
 557
 558 })();