@lmjs/core 1.0.6 → 2.0.0

package/src/workers/workRaw.js

@@ -0,0 +1,1097 @@
+//https://github.com/tanzeelkazi/web-worker
+/*eslint no-native-reassign:0 */
+(function ($) {
+    'use strict';
+
+    /**
+     * The WebWorker module.
+     * @module WebWorker
+     */
+    var WebWorker = null,
+        _WebWorker = null,
+        NativeWorker = null,
+
+        context = null,
+        className = null,
+
+        defaultContext = window,
+        defaultClassName = 'WebWorker',
+
+        State = null,
+
+        Action = null,
+
+        Event = null,
+        eventPrefix = 'webworker:',
+
+        EventMap = null,
+
+        Error = null,
+
+        slice = null,
+
+        key = null;
+
+    context = context || defaultContext;
+    className = className || defaultClassName;
+
+    WebWorker = context[className] || null;
+
+    if (WebWorker !== null) {
+        _WebWorker = WebWorker;
+    }
+
+    slice = Array.prototype.slice;
+    NativeWorker = window.Worker;
+
+    /**
+     * The main WebWorker class.
+     * @class WebWorker
+     * @constructor
+     * @param {Object|String} opts
+     *            The options to be passed into the constructor.
+     *            <br />
+     *            If you pass a `String`, the code will first search
+     *            for an element selector with the worker script.
+     *            If it does not find the element it will then use
+     *            it as a URL to the actual worker script.
+     */
+    WebWorker = function () {
+        this._constructor.apply(this, arguments);
+        return;
+    };
+
+    /**
+     * A jQuery object created from the webworker instance.
+     * @property _$
+     * @private
+     * @type {jQuery}
+     * @default $(this)
+     * @readOnly
+     */
+    WebWorker.prototype._$ = null;
+
+    /**
+     * The callback stack for the
+     * {{#crossLink "WebWorker/loading:method"}}{{/crossLink}},
+     * {{#crossLink "WebWorker/loaded:method"}}{{/crossLink}},
+     * {{#crossLink "WebWorker/starting:method"}}{{/crossLink}},
+     * {{#crossLink "WebWorker/started:method"}}{{/crossLink}},
+     * {{#crossLink "WebWorker/terminating:method"}}{{/crossLink}},
+     * and
+     * {{#crossLink "WebWorker/terminated:method"}}{{/crossLink}}
+     * hooks.
+     * @property _callbackStack
+     * @type {Object}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._callbackStack = null;
+
+    /**
+     * Stores the last error generated by the worker instance.
+     * @property _lastError
+     * @type {String}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._lastError = null;
+
+    /**
+     * Stores the log information for this worker instance. The log is not
+     * initialized unless explicity invoked by the
+     * {{#crossLink "WebWorker/log:method"}}{{/crossLink}} or
+     * {{#crossLink "WebWorker/getLog:method"}}{{/crossLink}} methods
+     * which internally call {{#crossLink "WebWorker/_initLog:method"}}{{/crossLink}}
+     * to initialize this property.
+     * @property _log
+     * @type {Array}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._log = null;
+
+    /**
+     * The native browser worker object. This is generated once the worker is loaded.
+     * @property _nativeWorker
+     * @type {Object}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._nativeWorker = null;
+
+    /**
+     * The current state of the worker. This value is updated internally by the worker.
+     * Valid values for this property are defined in {{#crossLink "WebWorker/State:property"}}{{/crossLink}}.
+     * @property _state
+     * @type {Number}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._state = null;
+
+    /**
+     * The `Blob` URL generated for the worker.
+     * @property _workerBlobUrl
+     * @type {String}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._workerBlobUrl = null;
+
+    /**
+     * The worker script contents (cached for further use).
+     * @property _workerScript
+     * @type {String}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._workerScript = null;
+
+    /**
+     * The worker URL (if provided)
+     * @property _workerUrl
+     * @type {String}
+     * @private
+     * @default null
+     */
+    WebWorker.prototype._workerUrl = null;
+
+
+    /**
+     * The main constructor calls this method. This method
+     * was moved out of the main constructor to keep the
+     * code clean.
+     * @method _constructor
+     * @param {Object} opts* Arguments to the main constructor
+     * @private
+     */
+    WebWorker.prototype._constructor = function (opts) {
+        var $scriptElement = null,
+            scriptContents = null,
+            workerUrl = null;
+
+        Object.defineProperty(this, '_$', {
+            "configurable": false,
+            "enumerable": true,
+            "value": $(this),
+            "writable": false
+        });
+
+        opts = opts || null;
+
+        if (opts === null) {
+            this.throwError(Error.INVALID_ARGUMENTS, null, true);
+        }
+
+        if (typeof opts === 'string') {
+            let strtr = "";
+            opts = $.trim(opts);
+
+            try {
+                if (window.hasOwnProperty(opts) && typeof window[opts] === "string") {
+                    strtr = window[opts];
+                    this._workerScript = strtr;
+                } else {
+                    $scriptElement = $(opts);
+                }
+            } catch (err) {
+                // Cannot be resolved as a selector
+            }
+
+
+            if ($scriptElement !== null && $scriptElement.length > 0) {
+                // Matching script element found
+                // Cache its contents
+                scriptContents = $scriptElement.text();
+                this._workerScript = scriptContents;
+            } else if (strtr == "") {
+                workerUrl = opts;
+            }
+        }
+
+        this._workerUrl = workerUrl;
+
+        this._callbackStack = {
+            "error": [],
+            "loading": [],
+            "loaded": [],
+            "starting": [],
+            "started": [],
+            "terminating": [],
+            "terminated": []
+        };
+
+        this._assignEventHandlers();
+
+        this._state = State.INITIALIZED;
+
+        this.trigger(Event.INITIALIZED);
+
+        return;
+    };
+
+    /**
+     * Initializes the log array when invoked.
+     * @method _initLog
+     * @private
+     */
+    WebWorker.prototype._initLog = function () {
+        this._log = [];
+        return this._log;
+    };
+
+    /**
+     * Returns the worker URL if one was provided during object instantiation.
+     * @method getUrl
+     * @return {String} The worker URL, `null` otherwise.
+     */
+    WebWorker.prototype.getUrl = function () {
+        return this._workerUrl;
+    };
+
+    /**
+     * Returns the worker blob URL if one has been generated.
+     * @method getBlobUrl
+     * @return {String} The worker blob URL, `null` otherwise.
+     */
+    WebWorker.prototype.getBlobUrl = function () {
+        return this._workerBlobUrl;
+    };
+
+    /**
+     * Returns the worker blob URL if one has been generated.
+     * @method getBlobUrl
+     * @return {Array} The log array of the worker.
+     */
+    WebWorker.prototype.getLog = function () {
+        var log;
+        log = this._log || this._initLog();
+        return log;
+    };
+
+    /**
+     * Returns the native browser worker instance if one has been generated.
+     * @method getNativeWorker
+     * @return {Object} The native worker instance, `null` otherwise.
+     */
+    WebWorker.prototype.getNativeWorker = function () {
+        return this._nativeWorker;
+    };
+
+    /**
+     * Returns the current state of the worker as an integer.
+     * Refer to {{#crossLink "WebWorker/State:property"}}{{/crossLink}} for state values.
+     * @method getState
+     * @return {Number} An integer representing the current state of the worker.
+     */
+    WebWorker.prototype.getState = function () {
+        return this._state;
+    };
+
+    /**
+     * Returns whether the worker script is loading.
+     * @method isLoading
+     * @return {Boolean} Returns `true` if the worker script is loading, `false` otherwise.
+     */
+    WebWorker.prototype.isLoading = function () {
+        return this.getState() === State.LOADING;
+    };
+
+    /**
+     * Returns whether the worker script is loaded.
+     * @method isLoaded
+     * @return {Boolean} Returns `true` if the worker script is loaded, `false` otherwise.
+     */
+    WebWorker.prototype.isLoaded = function () {
+        var state = this.getState();
+        return state >= State.LOADED && !this.isTerminated();
+    };
+
+    /**
+     * Returns whether the worker script is starting.
+     * @method isStarting
+     * @return {Boolean} Returns `true` if the worker script is starting, `false` otherwise.
+     */
+    WebWorker.prototype.isStarting = function () {
+        return this.getState() === State.STARTING;
+    };
+
+    /**
+     * Returns whether the worker script is started.
+     * @method isStarted
+     * @return {Boolean} Returns `true` if the worker script is started, `false` otherwise.
+     */
+    WebWorker.prototype.isStarted = function () {
+        var state = this.getState();
+        return state >= State.STARTED && !this.isTerminated();
+    };
+
+    /**
+     * Returns whether the worker script is terminating.
+     * @method isTerminating
+     * @return {Boolean} Returns `true` if the worker script is terminating, `false` otherwise.
+     */
+    WebWorker.prototype.isTerminating = function () {
+        return this.getState() === State.TERMINATING;
+    };
+
+    /**
+     * Returns whether the worker script is terminated.
+     * @method isTerminated
+     * @return {Boolean} Returns `true` if the worker script is terminated, `false` otherwise.
+     */
+    WebWorker.prototype.isTerminated = function () {
+        return this.getState() === State.TERMINATED;
+    };
+
+    /**
+     * Triggers the instance to load the worker script and generate a native browser worker.
+     * @method load
+     * @chainable
+     */
+    WebWorker.prototype.load = function () {
+        var self = this,
+            workerUrl = null,
+            onScriptLoaded = null;
+
+        if (self.isLoading() || self.isLoaded()) {
+            return self;
+        }
+
+        // Trigger event
+        self.trigger(Event.WORKER_LOADING);
+
+        workerUrl = self.getUrl() || null;
+        onScriptLoaded = function () {
+            var blob = null,
+                scriptContents = null;
+
+            scriptContents = self._workerScript;
+            scriptContents = WebWorker._workerScriptWrapper.replace(/\{\{main-function\}\}/g, scriptContents);
+
+            blob = new window.Blob([scriptContents], {
+                "type": "text/javascript"
+            });
+            self._workerBlobUrl = window.URL.createObjectURL(blob);
+
+            self._createWorker();
+        };
+
+        if (workerUrl === null) {
+            // Script already available
+            onScriptLoaded();
+        } else {
+            // Ajax request
+            $.ajax({
+                "async": true,
+                "url": workerUrl,
+                "dataType": 'text',
+                "crossDomain": true,
+                "success": function (responseText) {
+                    self._workerScript = responseText;
+                    onScriptLoaded();
+                },
+                "error": function () {
+                    self.throwError(Error.WORKER_DID_NOT_LOAD, arguments);
+                }
+            });
+        }
+
+        return self;
+    };
+
+    /**
+     * Concatenates log messages to internal log array.
+     * @method log
+     * @param {Mixed} data The data that you wish to be logged.
+     * @chainable
+     */
+    WebWorker.prototype.log = function (data) {
+        var log;
+
+        log = this._log || this._initLog();
+        log.push(data);
+
+        return this;
+    };
+
+    /**
+     * Generates the native browser worker and attaches the message parser to it.
+     * @method _createWorker
+     * @private
+     * @chainable
+     */
+    WebWorker.prototype._createWorker = function () {
+        this._nativeWorker = new NativeWorker(this.getBlobUrl());
+        this._attachMessageParser();
+        return this;
+    };
+
+    /**
+     * Assigns the basic internal event handlers to the worker instance.
+     * @method _assignEventHandlers
+     * @private
+     * @chainable
+     */
+    WebWorker.prototype._assignEventHandlers = function () {
+        function getCallbackStackExecutor(stackId) {
+            return function () {
+                var callbackStack = this._callbackStack[stackId],
+                    stateId,
+                    curCallback;
+
+                stateId = stackId.toUpperCase();
+
+                if (stateId in State) {
+                    // Set the current state of the worker
+                    // as long as it's a valid state.
+                    this._state = State[stateId];
+                }
+
+                /* eslint no-cond-assign:0 */
+                while (curCallback = callbackStack.pop()) {
+                    curCallback.apply(this, arguments);
+                }
+            };
+        }
+
+        this.on(Event.ERROR, getCallbackStackExecutor('error'));
+        this.on(Event.WORKER_LOADING, getCallbackStackExecutor('loading'));
+        this.on(Event.WORKER_LOADED, getCallbackStackExecutor('loaded'));
+        this.on(Event.WORKER_STARTING, getCallbackStackExecutor('starting'));
+        this.on(Event.WORKER_STARTED, getCallbackStackExecutor('started'));
+        this.on(Event.WORKER_TERMINATING, getCallbackStackExecutor('terminating'));
+        this.on(Event.WORKER_TERMINATED, getCallbackStackExecutor('terminated'));
+
+        return this;
+    };
+
+    function getCallbackStackUpdater(stackId) {
+        return function (callback) {
+            var callbackStack = this._callbackStack[stackId];
+
+            if (typeof callback === 'function') {
+                callbackStack.push(callback);
+            }
+
+            return this;
+        };
+    }
+
+    /**
+     * Hook for the error event.
+     * @method error
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.error = getCallbackStackUpdater('error');
+
+    /**
+     * Hook for the loading event.
+     * @method loading
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.loading = getCallbackStackUpdater('loading');
+
+    /**
+     * Hook for the loaded event.
+     * @method loaded
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.loaded = getCallbackStackUpdater('loaded');
+
+    /**
+     * Hook for the starting event.
+     * @method starting
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.starting = getCallbackStackUpdater('starting');
+
+    /**
+     * Hook for the started event.
+     * @method started
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.started = getCallbackStackUpdater('started');
+
+    /**
+     * Hook for the terminating event.
+     * @method terminating
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.terminating = getCallbackStackUpdater('terminating');
+
+    /**
+     * Hook for the terminated event.
+     * @method terminated
+     * @param {Function} callback The callback function that get's called when the event get's triggered.
+     * @chainable
+     */
+    WebWorker.prototype.terminated = getCallbackStackUpdater('terminated');
+
+    /**
+     * Start the worker (if it has loaded). Any arguments passed to this method
+     * will be passed internally to the worker script.
+     * <br />
+     * Note that you should start the worker only AFTER it has loaded. If you call this
+     * method before the worker has loaded it will fail silently.
+     * @method start
+     * @param {Mixed} args* Arguments to be passed internally to the worker
+     *                      script.<br />
+     *                      Please ensure that arguments are basic
+     *                      objects that can be cloned by the browser
+     *                      for `postMessage` interface.
+     * @chainable
+     */
+    WebWorker.prototype.start = function () {
+        var args = null;
+
+        if (this.isStarting() || this.isStarted()) {
+            return this;
+        }
+
+        args = slice.call(arguments);
+
+        if (!this.isLoaded()) {
+            this.on(Event.WORKER_LOADED, function () {
+                this.start.apply(this, args);
+            });
+
+            this.load();
+            return this;
+        }
+
+        this.trigger(Event.WORKER_STARTING);
+
+        this.sendMessage(Action.START, args);
+
+        return this;
+    };
+
+    /**
+     * This method acts as the main communications interface with the worker and is used internally.
+     * <br /><br />
+     * **You are recommended to use the trigger interface _ONLY_ as it is the most reliable mode of
+     * communication between the instance and the actual worker.**
+     * <br /><br />
+     * If you do understand the risks, you are welcome to use this method (a reason why it is
+     * left public instead of private).
+     * <br /><br />
+     * It's basic usage is very simple. Specify the `action`, which is the
+     * method name to call _inside_ the worker script, and the arguments to pass in. The worker
+     * does the rest of the heavy lifting.
+     * <br /><br />
+     * Note: This method is NOT synchronous and will not warn you of any errors.
+     * @method sendMessage
+     * @param {String} action The name of the method within the worker script to call.
+     * @param {Array} args The array of arguments to pass to the worker. Ensure that this data
+     *                     can be cloned by the browser for the `postMessage` interface.
+     * @chainable
+     */
+    WebWorker.prototype.sendMessage = function (action, args) {
+        var nativeWorker = null,
+            message = null;
+
+        action = action || null;
+        args = args || null;
+
+        if (action === null) {
+            return this;
+        }
+
+        message = {
+            "__isWebWorkerMsg": true
+        };
+
+        message.action = action;
+        message.args = args;
+
+        nativeWorker = this.getNativeWorker();
+
+        if (nativeWorker) {
+            nativeWorker.postMessage(message);
+        }
+
+        return this;
+    };
+
+    /**
+     * Attaches the message parser to the native worker. This allows the worker to hook into
+     * `postMessage` API and set up a communications protocol between the instance and the
+     * native browser worker.
+     * @method _attachMessageParser
+     * @private
+     * @chainable
+     */
+    WebWorker.prototype._attachMessageParser = function () {
+        var $nativeWorker = null;
+
+        $nativeWorker = $(this.getNativeWorker());
+
+        $nativeWorker.on('message', $.proxy(function (event) {
+            var originalEvent = event.originalEvent || event,
+                msg = originalEvent.data,
+                action = null,
+                args = null;
+
+            if (typeof msg === 'object'
+                && '__isWebWorkerMsg' in msg
+                && msg.__isWebWorkerMsg) {
+                action = msg.action;
+                args = msg.args;
+
+                this[action].apply(this, args);
+            }
+
+            return;
+        }, this));
+
+        $nativeWorker.on('error', $.proxy(this.throwError, this));
+
+        return this;
+    };
+
+    /**
+     * This method triggers the worker to terminate. Terminating is ASYNCHRONOUS. This method
+     * sets the ball rolling. It sends the message to the worker which may have a
+     * `terminateHandler` that can do some cleanup operations before control is passed back
+     * to the instance and the final terminate (`terminateNow`) is executed.
+     * @method terminate
+     * @chainable
+     */
+    WebWorker.prototype.terminate = function () {
+        var nativeWorker = this.getNativeWorker() || null;
+
+        if (nativeWorker) {
+            this.trigger(Event.WORKER_TERMINATING);
+            this.sendMessage(Action.TERMINATE, slice.call(arguments));
+        }
+
+        return this;
+    };
+
+    /**
+     * Terminates the worker _immediately_.
+     * <br />
+     * This method can be used to terminate the worker
+     * _immediately_, instead of waiting for the asynchronous terminate cycle to complete.
+     * <br />
+     * It is also called internally once the asynchronous `terminate` cycle
+     * passes control back to the instance to execute the final terminate.
+     * @method terminateNow
+     * @chainable
+     */
+    WebWorker.prototype.terminateNow = function () {
+        var nativeWorker = null;
+
+        if (!this.isTerminating()) {
+            this.trigger(Event.WORKER_TERMINATING);
+        }
+
+        nativeWorker = this.getNativeWorker() || null;
+
+        if (nativeWorker) {
+            nativeWorker.terminate();
+            this._nativeWorker = null;
+            this.trigger(Event.WORKER_TERMINATED);
+        }
+
+        return this;
+    };
+
+    /**
+     * Used to bind event listeners to the worker. Internally it uses the jQuery `.on` method.
+     * @method on
+     * @param {Mixed} args* Lookup the jQuery `.on` API for argument list.
+     * @chainable
+     */
+    WebWorker.prototype.on = function () {
+        var $worker = this._$;
+        $worker.on.apply($worker, arguments);
+        return this;
+    };
+
+    /**
+     * Used to bind event listeners to the worker for single execution. Internally it uses the jQuery `.one` method.
+     * @method one
+     * @param {Mixed} args* Lookup the jQuery `.one` API for argument list.
+     * @chainable
+     */
+    WebWorker.prototype.one = function () {
+        var $worker = this._$;
+        $worker.one.apply($worker, arguments);
+        return this;
+    };
+
+    /**
+     * Used to unbind event listeners from the worker. Internally it uses the jQuery `.off` method.
+     * @method off
+     * @param {Mixed} args* Lookup the jQuery `.off` API for argument list.
+     * @chainable
+     */
+    WebWorker.prototype.off = function () {
+        var $worker = this._$;
+
+        $worker.off.apply($worker, arguments);
+        this._assignEventHandlers();
+
+        return this;
+    };
+
+    /**
+     * Used to trigger events on the worker. Internally it uses a combination of the jQuery `.trigger` method
+     * and a custom trigger for triggering events on the native worker script.
+     * <br /><br />
+     * If an event type is recognized as an internal event type, the trigger is executed on the base instance
+     * using jQuery. Otherwise the `.sendMessage` API is used to pass the trigger to the worker script.
+     * @method trigger
+     * @param {Object} event This can be a string `eventType` or an object `event`. Please ensure that if using
+     *                       object events, that they are clonable by the browser for the `postMessage` API.
+     * @chainable
+     */
+    WebWorker.prototype.trigger = function (event) {
+        var passedEventString = false,
+            eventType = null,
+            eventArgs = null;
+
+        if (typeof event === 'object') {
+            eventType = event.type || null;
+        }
+
+        if (typeof event === 'string') {
+            eventType = event || null;
+            passedEventString = true;
+        }
+
+        if (eventType === null) {
+            return this;
+        }
+
+        if (eventType in EventMap) {
+            if (passedEventString) {
+                event = new $.Event(eventType);
+            }
+            event.worker = this;
+            eventArgs = [event];
+            if (arguments.length > 1) {
+                eventArgs = eventArgs.concat(slice.call(arguments, 1));
+            }
+
+            this._triggerSelf.apply(this, eventArgs);
+            return this;
+        }
+
+        if (passedEventString) {
+            event = {
+                "type": eventType,
+                "data": arguments[1] ? arguments[1] : {}
+            };
+        }
+        eventArgs = [event];
+
+        this.sendMessage(Action.TRIGGER_SELF, eventArgs);
+
+        return this;
+    };
+
+    /**
+     * You may want to trigger an event on the base worker instance irrespective of it's event type. Use this
+     * method to achieve the same.
+     * @method triggerSelf
+     * @param {Object} event This can be a string `eventType` or an object `event`.
+     * @chainable
+     */
+    WebWorker.prototype.triggerSelf = function (event) {
+        var eventType = null,
+            eventArgs = null;
+
+        event = event || null;
+
+        if (event === null) {
+            return this;
+        }
+
+        if (typeof event === 'string') {
+            eventType = event;
+            event = new $.Event(eventType);
+        }
+
+        event.originalEvent = event.originalEvent || event;
+        event.worker = this;
+        eventArgs = [event];
+        if (arguments.length > 1) {
+            eventArgs = eventArgs.concat(slice.call(arguments, 1));
+        }
+
+        this._triggerSelf.apply(this, eventArgs);
+
+        return this;
+    };
+
+    /**
+     * Internal method to trigger events on the base worker instance.
+     * @method _triggerSelf
+     * @private
+     * @param {Mixed} args* Arguments to `trigger`.
+     * @chainable
+     */
+    WebWorker.prototype._triggerSelf = function () {
+        var $worker = null;
+
+        $worker = this._$;
+        $worker.trigger.apply($worker, arguments);
+
+        return this;
+    };
+
+    /**
+     * Throw error on the worker instance. This internally triggers the `error` event.
+     * Optionally you can also make this method throw an exception.
+     * <br />
+     * This method also internally updates the `lastError` value on the instance
+     * and static properties.
+     * @method throwError
+     * @param {String} error Error string that describes the error.
+     * @param {Mixed} [data] Data that is to be associated with the error event.
+     * @param {Boolean} [throwException] Set to `true` if you want to throw an exception in addition to the error event.
+     * @chainable
+     */
+    WebWorker.prototype.throwError = function (error, data, throwException) {
+        var errorData = null;
+
+        error = error || Error.UNKNOWN;
+
+        if (typeof error === 'object') {
+            error = error.originalEvent || error;
+            errorData = error.data || null;
+        }
+
+        errorData = typeof data === 'undefined' ? errorData : data;
+        throwException = throwException || false;
+
+        this._lastError = error;
+        WebWorker._lastError = error;
+
+        if ('_triggerError' in this) {
+            this._triggerError(error, data, throwException);
+        }
+
+        if (throwException) {
+            throw new window.Error(error);
+        }
+
+        return this;
+    };
+
+    /**
+     * Internal method used to trigger the `error` event on the instance.
+     * @method _triggerError
+     * @private
+     * @param {String} error Error string that describes the error.
+     * @param {Mixed} [data] Data that is to be associated with the error event.
+     * @param {Boolean} [throwException] Set to `true` if you want to throw an exception in addition to the error event.
+     * @chainable
+     */
+    WebWorker.prototype._triggerError = function (error, data, throwException) {
+        var errorEvent = null;
+
+        errorEvent = new $.Event(Event.ERROR);
+        errorEvent.message = this.getLastError();
+        errorEvent.errorData = data;
+        errorEvent.throwsException = !!throwException;
+
+        this.trigger(errorEvent);
+        return this;
+    };
+
+    /**
+     * Returns the last error that was trigger on this worker instance.
+     * @method getLastError
+     * @return {String} The last error message that was thrown on this worker instance.
+     */
+    WebWorker.prototype.getLastError = function () {
+        return this._lastError;
+    };
+
+
+    // Static
+
+    /**
+     * The last error encountered across all WebWorker instances.
+     * @property _lastError
+     * @private
+     * @static
+     * @type {String}
+     */
+    WebWorker._lastError = null;
+
+    /**
+     * List of possible states the worker instance can be in. The worker instance
+     * can only be in one of these states at any given time.
+     * @property {Object} State
+     *     @property {Number} State.INITIALIZED 0
+     *     @property {Number} State.LOADING 1
+     *     @property {Number} State.LOADED 2
+     *     @property {Number} State.STARTING 3
+     *     @property {Number} State.STARTED 4
+     *     @property {Number} State.TERMINATING 5
+     *     @property {Number} State.TERMINATED 6
+     *
+     * @static
+     */
+    State = {
+        "INITIALIZED": 0,
+        "LOADING": 1,
+        "LOADED": 2,
+        "STARTING": 3,
+        "STARTED": 4,
+        "TERMINATING": 5,
+        "TERMINATED": 6
+    };
+    WebWorker.State = State;
+
+    /**
+     * List of pre-defined actions for the WebWorker instance.
+     *
+     * @property {Object} Action
+     *     @property {String} Action.START 'start'
+     *     @property {String} Action.TERMINATE 'terminate'
+     *     @property {String} Action.TERMINATE_NOW 'terminateNow'
+     *     @property {String} Action.TRIGGER 'trigger'
+     *     @property {String} Action.TRIGGER_SELF 'triggerSelf'
+     *
+     * @static
+     */
+    Action = {
+        "LOG": 'log',
+        "START": 'start',
+        "TERMINATE": 'terminate',
+        "TERMINATE_NOW": 'terminateNow',
+        "TRIGGER": 'trigger',
+        "TRIGGER_SELF": 'triggerSelf'
+    };
+    WebWorker.Action = Action;
+
+    /**
+     * List of pre-defined events for the WebWorker instance.
+     *
+     * @property {Object} Event
+     *     @property {String} Event.INITIALIZED 'webworker:initialized'
+     *     @property {String} Event.ERROR 'webworker:error'
+     *     @property {String} Event.WORKER_LOADING 'webworker:worker-loading'
+     *     @property {String} Event.WORKER_LOADED 'webworker:worker-loaded'
+     *     @property {String} Event.WORKER_STARTING 'webworker:worker-starting'
+     *     @property {String} Event.WORKER_STARTED 'webworker:worker-started'
+     *     @property {String} Event.WORKER_TERMINATING 'webworker:worker-terminating'
+     *     @property {String} Event.WORKER_TERMINATED 'webworker:worker-terminated'
+     *
+     * @static
+     */
+    Event = {
+        "INITIALIZED": 'initialized',
+        "ERROR": 'error',
+
+        "WORKER_LOADING": 'worker-loading',
+        "WORKER_LOADED": 'worker-loaded',
+
+        "WORKER_STARTING": 'worker-starting',
+        "WORKER_STARTED": 'worker-started',
+
+        "WORKER_TERMINATING": 'worker-terminating',
+        "WORKER_TERMINATED": 'worker-terminated'
+    };
+    WebWorker.Event = Event;
+
+    /**
+     * Reverse mapping of pre-defined events for faster lookup.
+     * @property EventMap
+     * @static
+     * @type {Object}
+     */
+    EventMap = {};
+    WebWorker.EventMap = EventMap;
+
+    // Add eventPrefix to all event types
+    for (key in Event) {
+        Event[key] = eventPrefix + Event[key];
+        EventMap[Event[key]] = key;
+    }
+
+    /**
+     * Pre-defined list of errors for the WebWorker instance.
+     *
+     * @property {Object} Error
+     *     @property {String} Error.UNKNOWN "An unknown error occured."
+     *     @property {String} Error.INVALID_ARGUMENTS "Invalid arguments were supplied to this method."
+     *     @property {String} Error.WORKER_DID_NOT_LOAD "Unable to load worker."
+     *
+     * @static
+     */
+    Error = {
+        "UNKNOWN": "An unknown error occured.",
+        "INVALID_ARGUMENTS": "Invalid arguments were supplied to this method.",
+        "WORKER_DID_NOT_LOAD": "Unable to load worker."
+    };
+    WebWorker.Error = Error;
+
+    /**
+     * This is the worker script wrapper that is internally used by the base class
+     * to establish communication from within the worker.
+     * @property _workerScriptWrapper
+     * @type {String}
+     * @private
+     */
+    WebWorker._workerScriptWrapper = 'var e=null,t=null,n=null,r={};e={{state-data}};t={{action-data}};n={{event-data}};self._callbackStack=null;self._listeners=r;self._isTerminating=false;self._state=null;self.State=e;self.Action=t;self.Event=n;self._assignEventHandlers=function(){function t(t){return function(){var n=self._callbackStack[t],r,i;r=t.toUpperCase();if(r in e){self._state=e[r]}while(i=n.pop()){i.apply(self,arguments)}}}self.on(n.WORKER_TERMINATING,t("terminating"));return self};self.getState=function(){return this._state};self.isInitialized=function(){var e=self.getState();return e!==null&&e>=0};self.isTerminating=function(){return self.getState()===e.TERMINATING};self._main=function(){var startArgs=arguments;{{main-function}};return self};self._init=function(){self._callbackStack={terminating:[]};self._assignEventHandlers();self._state=e.INITIALIZED;self.trigger(n.WORKER_LOADED);return self};self.start=function(){if(!self.isInitialized()){return self}self.triggerSelf(n.WORKER_STARTING);self._main.apply(self,arguments);self.triggerSelf(n.WORKER_STARTED);self.trigger(n.WORKER_STARTED);return self};self.log=function(e){self.sendMessage(t.LOG,[e]);return self};self.on=function(e,t){e+="";t=t||null;if(typeof t!=="function"){return self}if(!(e in r)){r[e]=[]}r[e].push(t);return self};self.one=function(e,t){var n=null;n=function(){t.apply(this,arguments);self.off(e,n);return};self.on(e,n);return};self.off=function(e,t){var n=null;e=e||null;t=t||null;if(e===null&&t===null){for(n in r){delete r[n]}self._assignEventHandlers();return self}self._removeListenerFromEventType(e,t);return self};self._removeListenerFromEventType=function(e,t){var n=r[e],i=0;t=t||null;if(t===null){r[e]=[];return self}for(;i<n.length;i++){if(n[i]===t){n.splice(i,1);i--}}return self};self.terminating=function(e){var t=self._callbackStack.terminating;if(typeof e==="function"){t.push(e)}return self};self.trigger=function(e,n){var r=null;e=e||null;if(e===null){return self}if(typeof e==="string"){r=e||null;e={type:r}}else if(typeof e==="object"){r=e.type||null;n=e.data}if(r===null){return self}e.data=n;self.sendMessage(t.TRIGGER_SELF,[e]);return self};self.triggerSelf=function(e,t){var n=null,i=null,s=null,o=null,u=0;e=e||null;if(e===null){return this}if(typeof e==="string"){n=e||null;e={type:e}}else if(typeof e==="object"){n=e.type||null;t=e.data}if(n===null){return this}e.data=t;i=r[n]||null;if(i===null){return this}s=i.length;for(u=0;u<s;u++){o=i[u];o.apply(this,[e]);if(s!==i.length){u--;s=i.length}}return this};self.sendMessage=function(e,t){var n=null;e=e||null;t=t||[];if(e===null){return self}n={__isWebWorkerMsg:true};n.action=e;n.args=t;self.postMessage(n);return self};self.terminate=function(e){e=!!e;if(!self.isTerminating()){self._setTerminatingStatus();self.triggerSelf(n.WORKER_TERMINATING);self.trigger(n.WORKER_TERMINATING)}self.sendMessage(t.TERMINATE_NOW,[]);if(e){self._nativeClose()}return self};self.terminateNow=function(){return self.terminate(true)};self._setTerminatingStatus=function(){self._state=e.TERMINATING;return self};self._nativeClose=self.close;self.close=self.terminate;self.addEventListener("message",function(e){var t=e.originalEvent||e,n=t.data,r=null,i=null;if(typeof n==="object"&&"__isWebWorkerMsg"in n&&n.__isWebWorkerMsg){r=n.action;i=n.args;self[r].apply(self,i)}},false);self._init()';
+
+    WebWorker._workerScriptWrapper = WebWorker._workerScriptWrapper.replace(/\{\{state-data\}\}/g, JSON.stringify(State))
+        .replace(/\{\{action-data\}\}/g, JSON.stringify(Action))
+        .replace(/\{\{event-data\}\}/g, JSON.stringify(Event));
+
+
+    /**
+     * Retrieves the last error thrown by any WebWorker instance.
+     * @method getLastError
+     * @static
+     * @return {String} The last error string thrown by any WebWorker instance.
+     */
+    WebWorker.getLastError = WebWorker.prototype.getLastError;
+
+    /**
+     * A jQuery-like method to assign the WebWorker class under a different context and className.
+     * You may either provide the context and class name as params
+     * OR use the return value to set it
+     * OR both.
+     * @method noConflict
+     * @static
+     * @param {Object} context The context to which the WebWorker instance needs to be associated.
+     * @param {String} className The class name with which the WebWorker instance will be identified.
+     * @return {String} The last error string thrown by any WebWorker instance.
+     */
+    WebWorker.noConflict = function (context, className) {
+        context = context || null;
+        className = className || null;
+
+        if (defaultContext[defaultClassName] === WebWorker) {
+            delete defaultContext[defaultClassName];
+            if (_WebWorker) {
+                defaultContext[defaultClassName] = _WebWorker;
+            }
+        }
+
+        if (context && className) {
+            context[className] = WebWorker;
+        }
+
+        return WebWorker;
+    };
+
+    context[className] = WebWorker;
+
+    return;
+})(jQuery);