fix

assets/core/core.js

@@ -27,6 +27,11 @@ kit.config = kit.config || {};
         this.registerPlugins(plugins);
     };
 
+    /**
+     *
+     * @type {kit.PluginManager|PluginManager}
+     * @private
+     */
     var __proto = PluginManager.prototype;
 
     __proto.__checkState = function(pluginId, state){
@@ -50,7 +55,6 @@ kit.config = kit.config || {};
     };
 
     /**
-     *
      * @param pluginId
      * @param {kitModuleTypeLoader|{}} config
      * @return {boolean}
@@ -456,7 +460,7 @@ kit.config = kit.config || {};
 
         if(!this.__checkState(pluginId, stateList.registered)) {
             console.warn('PluginManager.require: plugin ' + pluginId + ' is not register');
-            return false;
+            return undefined;
         }
         if(typeof callback !== 'function') {
             callback = function(){};
@@ -626,6 +630,7 @@ kit.config = kit.config || {};
         debug: false,
         defaultPhoneMask: '+7 (999) 999-99-99',
     };
+
     var manager = new PluginManager(global);
     manager.register('PluginManager', {
         alias: 'pm',
@@ -649,7 +654,7 @@ kit.config = kit.config || {};
     global.ready = manager.ready.bind(manager);
     global.exec = manager.exec.bind(manager);
     global.require = manager.require.bind(manager);
-    /** @type {kitCore} */
+    /** @type {kit} */
     window.__pmGlobal__ = global;
 })(kit);
 

assets/core/core.register.js

@@ -30,7 +30,7 @@ __PluginManager__.registerPlugins({
     },
     jQuery: {
         path: __pmConfig__.assetsPath + '/jquery',
-        module: '/jquery.min.js',
+        module: '/jquery.js',
         type: 'loader',
         alias: '$',
     },
@@ -283,6 +283,25 @@ __PluginManager__.registerPlugins({
         js: '/makeCSSAnimations.js',
         deps: ['jQuery', 'support'],
     },
+    mCustomScrollbar: {
+        path: __pmConfig__.assetsPath + '/mCustomScrollbar',
+        alias: 'malihu-custom-scrollbar-plugin',
+        js: '/mCustomScrollbar.js',
+        css: '/jquery.mCustomScrollbar.css',
+        deps: ['jQuery', 'jqueryMousewheel'],
+        onInstall: function (plugin) {
+            plugin.module.exports(kit.require('jQuery'));
+        }
+    },
+    jqueryMousewheel: {
+        path: __pmConfig__.assetsPath + '/jqueryMousewheel',
+        alias: 'jquery-mousewheel',
+        js: '/jquery.mousewheel.js',
+        deps: ['jQuery'],
+        onInstall: function (plugin) {
+            plugin.module.exports(kit.require('jQuery'));
+        }
+    },
 
 });
 

assets/jqueryMousewheel/jquery.mousewheel.js

@@ -0,0 +1,228 @@
+/** @module jqueryMousewheel */
+kit.PluginManager.register('jqueryMousewheel', function(module, exports, require, global){
+    var jQuery = require('jQuery');
+
+    /*!
+     * jQuery Mousewheel 3.1.13
+     *
+     * Copyright jQuery Foundation and other contributors
+     * Released under the MIT license
+     * http://jquery.org/license
+     */
+
+    (function (factory) {
+        if ( typeof define === 'function' && define.amd ) {
+            // AMD. Register as an anonymous module.
+            define(['jquery'], factory);
+        } else if (typeof exports === 'object') {
+            // Node/CommonJS style for Browserify
+            module.exports = factory;
+        } else {
+            // Browser globals
+            factory(jQuery);
+        }
+    }(function ($) {
+
+        var toFix  = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
+            toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
+                ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
+            slice  = Array.prototype.slice,
+            nullLowestDeltaTimeout, lowestDelta;
+
+        if ( $.event.fixHooks ) {
+            for ( var i = toFix.length; i; ) {
+                $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
+            }
+        }
+
+        var special = $.event.special.mousewheel = {
+            version: '3.1.12',
+
+            setup: function() {
+                if ( this.addEventListener ) {
+                    for ( var i = toBind.length; i; ) {
+                        this.addEventListener( toBind[--i], handler, false );
+                    }
+                } else {
+                    this.onmousewheel = handler;
+                }
+                // Store the line height and page height for this particular element
+                $.data(this, 'mousewheel-line-height', special.getLineHeight(this));
+                $.data(this, 'mousewheel-page-height', special.getPageHeight(this));
+            },
+
+            teardown: function() {
+                if ( this.removeEventListener ) {
+                    for ( var i = toBind.length; i; ) {
+                        this.removeEventListener( toBind[--i], handler, false );
+                    }
+                } else {
+                    this.onmousewheel = null;
+                }
+                // Clean up the data we added to the element
+                $.removeData(this, 'mousewheel-line-height');
+                $.removeData(this, 'mousewheel-page-height');
+            },
+
+            getLineHeight: function(elem) {
+                var $elem = $(elem),
+                    $parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
+                if (!$parent.length) {
+                    $parent = $('body');
+                }
+                return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
+            },
+
+            getPageHeight: function(elem) {
+                return $(elem).height();
+            },
+
+            settings: {
+                adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
+                normalizeOffset: true  // calls getBoundingClientRect for each event
+            }
+        };
+
+        $.fn.extend({
+            mousewheel: function(fn) {
+                return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
+            },
+
+            unmousewheel: function(fn) {
+                return this.unbind('mousewheel', fn);
+            }
+        });
+
+
+        function handler(event) {
+            var orgEvent   = event || window.event,
+                args       = slice.call(arguments, 1),
+                delta      = 0,
+                deltaX     = 0,
+                deltaY     = 0,
+                absDelta   = 0,
+                offsetX    = 0,
+                offsetY    = 0;
+            event = $.event.fix(orgEvent);
+            event.type = 'mousewheel';
+
+            // Old school scrollwheel delta
+            if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
+            if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
+            if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
+            if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
+
+            // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
+            if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
+                deltaX = deltaY * -1;
+                deltaY = 0;
+            }
+
+            // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
+            delta = deltaY === 0 ? deltaX : deltaY;
+
+            // New school wheel delta (wheel event)
+            if ( 'deltaY' in orgEvent ) {
+                deltaY = orgEvent.deltaY * -1;
+                delta  = deltaY;
+            }
+            if ( 'deltaX' in orgEvent ) {
+                deltaX = orgEvent.deltaX;
+                if ( deltaY === 0 ) { delta  = deltaX * -1; }
+            }
+
+            // No change actually happened, no reason to go any further
+            if ( deltaY === 0 && deltaX === 0 ) { return; }
+
+            // Need to convert lines and pages to pixels if we aren't already in pixels
+            // There are three delta modes:
+            //   * deltaMode 0 is by pixels, nothing to do
+            //   * deltaMode 1 is by lines
+            //   * deltaMode 2 is by pages
+            if ( orgEvent.deltaMode === 1 ) {
+                var lineHeight = $.data(this, 'mousewheel-line-height');
+                delta  *= lineHeight;
+                deltaY *= lineHeight;
+                deltaX *= lineHeight;
+            } else if ( orgEvent.deltaMode === 2 ) {
+                var pageHeight = $.data(this, 'mousewheel-page-height');
+                delta  *= pageHeight;
+                deltaY *= pageHeight;
+                deltaX *= pageHeight;
+            }
+
+            // Store lowest absolute delta to normalize the delta values
+            absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
+
+            if ( !lowestDelta || absDelta < lowestDelta ) {
+                lowestDelta = absDelta;
+
+                // Adjust older deltas if necessary
+                if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
+                    lowestDelta /= 40;
+                }
+            }
+
+            // Adjust older deltas if necessary
+            if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
+                // Divide all the things by 40!
+                delta  /= 40;
+                deltaX /= 40;
+                deltaY /= 40;
+            }
+
+            // Get a whole, normalized value for the deltas
+            delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
+            deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
+            deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
+
+            // Normalise offsetX and offsetY properties
+            if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
+                var boundingRect = this.getBoundingClientRect();
+                offsetX = event.clientX - boundingRect.left;
+                offsetY = event.clientY - boundingRect.top;
+            }
+
+            // Add information to the event object
+            event.deltaX = deltaX;
+            event.deltaY = deltaY;
+            event.deltaFactor = lowestDelta;
+            event.offsetX = offsetX;
+            event.offsetY = offsetY;
+            // Go ahead and set deltaMode to 0 since we converted to pixels
+            // Although this is a little odd since we overwrite the deltaX/Y
+            // properties with normalized deltas.
+            event.deltaMode = 0;
+
+            // Add event and delta to the front of the arguments
+            args.unshift(event, delta, deltaX, deltaY);
+
+            // Clearout lowestDelta after sometime to better
+            // handle multiple device types that give different
+            // a different lowestDelta
+            // Ex: trackpad = 3 and mouse wheel = 120
+            if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
+            nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
+
+            return ($.event.dispatch || $.event.handle).apply(this, args);
+        }
+
+        function nullLowestDelta() {
+            lowestDelta = null;
+        }
+
+        function shouldAdjustOldDeltas(orgEvent, absDelta) {
+            // If this is an older event and the delta is divisable by 120,
+            // then we are assuming that the browser is treating this as an
+            // older mouse wheel event and that we should divide the deltas
+            // by 40 to try and get a more usable deltaFactor.
+            // Side note, this actually impacts the reported scroll distance
+            // in older browsers and can cause scrolling to be slower than native.
+            // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
+            return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
+        }
+
+    }));
+
+});
+

tests/jqueryMousewheelTest.php

@@ -0,0 +1,19 @@
+<script src="../assets/config/config.js"></script>
+<script src="../assets/core/core.js"></script>
+<script src="../assets/core/core.register.js"></script>
+
+<div  class="kit-wrapper">
+    <div class="kit-logger"></div>
+</div>
+<script>
+    kit.ready(['jquery-mousewheel', 'testing'], function () {
+
+        $ = kit.jQuery;
+
+        var unit = new kit.testing.Unit();
+
+        unit.assertSame('function', typeof $.fn.mousewheel, '$.fn.mousewheel');
+        unit.assertSame('object', typeof $.event.special.mousewheel, '$.event.special.mousewheel');
+
+    });
+</script>