GEEKING

RobloxHybrid/src/base.js

@@ -0,0 +1,188 @@
+//
+// RobloxHybrid
+//
+var require, define;
+
+//---------------------------------------------------
+(function () {
+    // Loaded modules
+    var modules = {};
+
+    // Stack of moduleIds currently being built.
+    var requireStack = [];
+    
+    // Map of module ID -> index into requireStack of modules currently being built.
+    var inProgressModules = {};
+
+    var nativePrefix = (function() {
+        var ua = navigator.userAgent.toLowerCase();
+        var isNative = ua.indexOf("hybrid") != -1;
+        if(isNative) {
+            // iOS
+            if(ua.indexOf("ipad") != -1 || ua.indexOf("iphone") != -1) {
+                return "iOS";
+            }
+            
+            // Android
+            if(ua.indexOf("android") != -1) {
+                return "Android";
+            }
+        }
+        return null;
+    })();
+
+    function build(module) {
+        var factory = module.factory;
+        var localRequire = require;
+
+        module.exports = createBaseModule(module);
+
+        delete module.factory;
+        factory(localRequire, module.exports, module);
+
+        // Check if there's a native implementation available
+        if(nativePrefix) {
+            var nativeModuleID = module.id + "/Native";
+            var nativeModule = modules[nativeModuleID];
+
+            if( !nativeModule && module.options && module.options.autoGenerateNative ) {
+                nativeModule = autoGenerateNative(factory, module.options);
+            }
+
+            // If exists, build the native implementation
+            if( nativeModule ) {
+                nativeModule.factory(localRequire, module.exports, module);
+                delete nativeModule.factory;
+            }
+
+            // Check if there's a platform specific implementation available
+            var platformModuleID = module.id + "/" + nativePrefix;
+            var platformModule = modules[platformModuleID];
+            if(  platformModule ) {
+                platformModule.factory(localRequire, module.exports, module);
+                delete platformModule.factory;
+            }
+        }
+
+        // Initialize the module
+        if(module.exports && module.exports.init && typeof module.exports.init === "function") {
+            module.exports.init();
+        }
+
+        return module.exports;
+    }
+
+    // Common members and methods for each module
+    function createBaseModule(module) {
+        var exports = {};
+
+        // Native modules override this member
+        exports.isNative = false;
+
+        // This function returns true in the callback if the
+        // function is supported natively by the module
+        exports.supports = function(functionName, callback) {
+            if(callback) {
+                callback(false);
+            }
+        };
+
+        return exports;
+    }
+
+    function autoGenerateNative(nativeModuleID, options) {
+
+        // This factory replaces every function
+        var generatedFactory = function(require, exports, module) {
+            
+            var bridge = require("Bridge");
+
+            // Iterate over all the exports to find and override the functions
+            for(var prop in exports) {
+                
+                (function() {
+                    var currentProp = prop;
+
+                    var func = exports[currentProp];
+                    if(func && typeof func === "function"){
+
+                        // Extract parameter names from function
+                        var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+                        var ARGUMENT_NAMES = /([^\s,]+)/g;
+                        var fnStr = func.toString().replace(STRIP_COMMENTS, '');
+                        var paramNames = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
+                        if(paramNames === null) {
+                            paramNames = [];
+                        }
+
+                        // Overrided function
+                        exports[currentProp] = function() {
+
+                            var callback = null;
+                            var parameters = {};
+
+                            // Find the callback function in the argument list
+                            // (It should be the first and only function)
+                            for(var i = 0; i < arguments.length; ++i) {
+                                var paramName = paramNames[i] || ("" + i);
+                                var paramValue = arguments[i];
+
+                                if(typeof paramValue === "function") {
+                                    callback = paramValue;
+                                }
+
+                                parameters[paramName] = paramValue;
+                            }
+
+                            bridge.execute(module.id, currentProp, parameters, callback);
+                        };
+                    }
+                })();
+            }
+        };
+
+        delete options.autoGenerateNative;
+
+        return define(nativeModuleID, options, generatedFactory);
+    }
+
+    require = function (id) {
+        if (!modules[id]) {
+            throw "module " + id + " not found";
+        } else if (id in inProgressModules) {
+            var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
+            throw "Cycle in require graph: " + cycle;
+        }
+        if (modules[id].factory) {
+            try {
+                inProgressModules[id] = requireStack.length;
+                requireStack.push(id);
+                return build(modules[id]);
+            } finally {
+                delete inProgressModules[id];
+                requireStack.pop();
+            }
+        }
+        return modules[id].exports;
+    };
+
+    define = function (id, options, factory) {
+        if (modules[id]) {
+            throw "module " + id + " already defined";
+        }
+
+        modules[id] = {
+            id: id,
+            options: options,
+            factory: factory
+        };
+
+        return modules[id];
+    };
+
+    define.remove = function (id) {
+        delete modules[id];
+    };
+
+    define.moduleMap = modules;
+})();