My-Commerce_core 1.0.0

data/public/javascripts/jquery.suggest.js

@@ -0,0 +1,276 @@
+	
+	/*
+	 *	jquery.suggest 1.1 - 2007-08-06
+	 *	
+	 *	Uses code and techniques from following libraries:
+	 *	1. http://www.dyve.net/jquery/?autocomplete
+	 *	2. http://dev.jquery.com/browser/trunk/plugins/interface/iautocompleter.js	
+	 *
+	 *	All the new stuff written by Peter Vulgaris (www.vulgarisoip.com)	
+	 *	Feel free to do whatever you want with this file
+	 *
+	 */
+	
+	(function($) {
+        var defaults = {
+          delay: 100,
+          resultsClass: 'jquery-suggestion-results',
+          selectClass: 'jquery-suggestion-select',
+          matchClass: 'jquery-suggestion-match',
+          minchars: 2,
+          onSelect: function($input, $result) {
+              $input.val($result.data('autocomplete:value'));
+          },
+          maxCacheSize: 65536,
+          source: '',
+          method: 'get',
+          dataType: 'json',
+          params: '',
+          queryParam: 'q'
+        };
+
+		$.suggest = function(input, options) {
+            options = $.extend({}, defaults, options);
+
+			var $input = $(input).attr("autocomplete", "off");
+			var $results = $('<ul></ul>');
+
+			var timeout = false;		// hold timeout ID for suggestion results to appear	
+			var prevLength = 0;			// last recorded length of $input.val()
+			var cache = [];				// cache MRU list
+			var cacheSize = 0;			// size of cache in chars (bytes?)
+			
+			$results.addClass(options.resultsClass).appendTo('body').hide();
+
+			resetPosition();
+			$(window)
+				.load(resetPosition)		// just in case user is changing size of page while loading
+				.resize(resetPosition);
+
+			$input.blur(function() {
+				setTimeout(function() { $results.hide() }, 200);
+			});
+			
+			// help IE users if possible
+			if ($results.bgiframe) $results.bgiframe();
+
+			// I really hate browser detection, but I don't see any other way
+			if ($.browser.mozilla)
+				$input.keypress(processKey);	// onkeypress repeats arrow keys in Mozilla/Opera
+			else
+				$input.keydown(processKey);		// onkeydown repeats arrow keys in IE/Safari
+
+			function resetPosition() {
+				// requires jquery.dimension plugin
+				var offset = $input.offset();
+				$results.css({
+					top: (offset.top + input.offsetHeight) + 'px',
+					left: offset.left + 'px'
+				});
+			}
+			
+			function processKey(e) {
+				// handling up/down/escape requires results to be visible
+				// handling enter/tab requires that AND a result to be selected
+				if ((/27$|38$|40$/.test(e.keyCode) && $results.is(':visible')) ||
+					(/^13$|^9$/.test(e.keyCode) && getCurrentResult())) {
+		            
+		            if (e.preventDefault)
+		                e.preventDefault();
+					if (e.stopPropagation)
+		                e.stopPropagation();
+
+					e.cancelBubble = true;
+					e.returnValue = false;
+				
+					switch(e.keyCode) {
+						case 38: // up
+							prevResult();
+							break;
+						case 40: // down
+							nextResult();
+							break;
+						case 9:  // tab
+						case 13: // return
+							selectCurrentResult();
+							break;
+						case 27: //	escape
+							$results.hide();
+							break;
+					}
+				}
+                else if ($input.val().length != prevLength) {
+					if (timeout) 
+						clearTimeout(timeout);
+					timeout = setTimeout(suggest, options.delay);
+					prevLength = $input.val().length;
+				}			
+			}
+			
+			function suggest() {
+				var q = $.trim($input.val());
+
+				if (q.length >= options.minchars) {
+					cached = checkCache(q);
+					if (cached) {
+						displayItems(cached['items']);
+					}
+                    else {
+                        var params = options.queryParam + '=' + q + (options.params.length ? '&' + options.params : '');
+                        $.ajax({
+                           type: options.method,
+                           url: options.source,
+                           dataType: options.dataType,
+                           data: params,
+                           success: function(data) {
+                               $results.hide();
+
+                               displayItems(data);
+                               addToCache(q, data);
+                           },
+                           error: function(xmlhttp, text) {
+                               $results.hide();
+                               alert(text);
+                           }
+                        });
+					}
+				}
+                else {
+					$results.hide();
+				}
+			}
+			
+			function checkCache(q) {
+				for (var i = 0; i < cache.length; i++)
+					if (cache[i]['q'] == q) {
+						cache.unshift(cache.splice(i, 1)[0]);
+						return cache[0];
+					}
+				return false;
+			}
+			
+			function addToCache(q, items) {
+                var size = 0;
+                $.each(items, function() {
+                   ++size;
+                });
+
+				while (cache.length && (cacheSize + size > options.maxCacheSize)) {
+					var cached = cache.pop();
+					cacheSize -= cached['size'];
+				}
+				
+				cache.push({
+					q: q,
+					size: size,
+					items: items
+				});
+				cacheSize += size;
+			}
+			
+			function displayItems(items) {
+				if (!items)
+					return;
+				var empty = true;
+                $results.empty();
+				$.each(items, function(value, display) {
+                    var $item = $('<li></li>').html(display).data('autocomplete:value', value);
+                    $results.append($item);
+                    empty = false;
+                });
+
+                if (empty) {
+					$results.hide();
+					return;
+				}
+
+                resetPosition();
+				$results
+                    .width($input.width())
+                    .show()
+					.children('li')
+					.mouseover(function() {
+						$results.children('li').removeClass(options.selectClass);
+						$(this).addClass(options.selectClass);
+					})
+					.click(function(e) {
+						e.preventDefault(); 
+						e.stopPropagation();
+						selectCurrentResult();
+					});		
+			}
+			
+			function parseTxt(txt, q) {
+				var items = [];
+				var tokens = txt.split(options.delimiter);
+				
+				// parse returned data for non-empty items
+				for (var i = 0; i < tokens.length; i++) {
+					var token = $.trim(tokens[i]);
+					if (token) {
+						token = token.replace(
+							new RegExp(q, 'ig'), 
+							function(q) { return '<span class="' + options.matchClass + '">' + q + '</span>' }
+							);
+						items[items.length] = token;
+					}
+				}
+				return items;
+			}
+			
+			function getCurrentResult() {
+				if (!$results.is(':visible'))
+					return false;
+			
+				var $currentResult = $results.children('li.' + options.selectClass);
+				if (!$currentResult.length)
+					$currentResult = false;
+					
+				return $currentResult;
+			}
+			
+			function selectCurrentResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult) {
+                    options.onSelect.call(this, $input, $currentResult);
+					$results.hide();
+				}
+			}
+			
+			function nextResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult)
+					$currentResult
+						.removeClass(options.selectClass)
+						.next()
+							.addClass(options.selectClass);
+				else
+					$results.children('li:first-child').addClass(options.selectClass);
+			}
+			
+			function prevResult() {
+				$currentResult = getCurrentResult();
+			
+				if ($currentResult)
+					$currentResult
+						.removeClass(options.selectClass)
+						.prev()
+							.addClass(options.selectClass);
+				else
+					$results.children('li:last-child').addClass(options.selectClass);
+			}
+		}
+		
+		$.fn.suggest = function(source, options) {
+			if (!source)
+				return;
+            options.source = source;
+			this.each(function() {
+				new $.suggest(this, options);
+			});
+			return this;
+		};
+	})(jQuery);
+	

data/public/javascripts/jquery.template.js

@@ -0,0 +1,255 @@
+/**
+ * jQuery Templates
+ *
+ * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+ * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
+ *
+ * Written by: Stan Lemon <stanlemon@mac.com>
+ *
+ * Based off of the Ext.Template library, available at:
+ * http://www.extjs.com
+ *
+ * This library provides basic templating functionality, allowing for macro-based
+ * templates within jQuery.
+ *
+ * Basic Usage:
+ *
+ * var t = $.template('<div id="foo">Hello ${name}, how are you ${question}?  I am ${me:substr(0,10)}</div>');
+ *
+ * $(selector).append( t , {
+ *     name: 'Stan',
+ *     question: 'feeling',
+ *     me: 'doing quite well myself, thank you very much!'
+ * });
+ *
+ * Requires: jQuery 1.2+
+ *
+ *
+ * @todo    Add callbacks to the DOM manipulation methods, so that events can be bound
+ *          to template nodes after creation.
+ */
+(function($){
+	
+	/**
+	 * Create a New Template
+	 */
+	$.template = function(html, options) {
+		return new $.template.instance(html, options);
+	};
+
+	/**
+	 * Template constructor - Creates a new template instance.
+	 *
+	 * @param 	html 	The string of HTML to be used for the template.
+	 * @param 	options An object of configurable options.  Currently
+	 * 			you can toggle compile as a boolean value and set a custom
+	 *          template regular expression on the property regx by
+	 *          specifying the key of the regx to use from the regx object.
+	 */
+	$.template.instance = function(html, options) {
+        // If a custom regular expression has been set, grab it from the regx object
+        if ( options && options['regx'] ) options.regx = this.regx[ options.regx ];
+
+		this.options = $.extend({
+			compile: 		false,
+			regx:           this.regx.standard
+		}, options || {});
+
+		this.html = html;
+
+		if (this.options.compile) {
+			this.compile();   
+		}
+		this.isTemplate = true;
+	};
+
+	/**
+	 * Regular Expression for Finding Variables
+	 *
+	 * The default pattern looks for variables in JSP style, the form of: ${variable}
+	 * There are also regular expressions available for ext-style variables and
+	 * jTemplate style variables.
+	 *
+	 * You can add your own regular expressions for variable ussage by doing.
+	 * $.extend({ $.template.re , {
+	 *     myvartype: /...../g
+	 * }
+	 *
+	 * Then when creating a template do:
+	 * var t = $.template("<div>...</div>", { regx: 'myvartype' });
+	 */
+	$.template.regx = $.template.instance.prototype.regx = {
+	    jsp:        /\$\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
+        ext:        /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
+        jtemplates: /\{\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}\}/g
+	};
+	
+	/**
+	 * Set the standard regular expression to be used.
+	 */
+	$.template.regx.standard = $.template.regx.jsp;
+	
+	/**
+	 * Variable Helper Methods
+	 *
+	 * This is a collection of methods which can be used within the variable syntax, ie:
+	 * ${variable:substr(0,30)} Which would only print a substring, 30 characters in length
+	 * begining at the first character for the variable named "variable".
+	 *
+	 * A basic substring helper is provided as an example of how you can define helpers.
+	 * To add more helpers simply do:
+	 * $.extend( $.template.helpers , {
+	 *	 sampleHelper: function() { ... }	
+	 * });
+	 */
+	$.template.helpers = $.template.instance.prototype.helpers = {
+		substr : function(value, start, length){
+			return String(value).substr(start, length);
+		}
+	};
+
+
+	/**
+	 * Template Instance Methods
+	 */
+	$.extend( $.template.instance.prototype, {
+		
+		/**
+		 * Apply Values to a Template
+		 *
+		 * This is the macro-work horse of the library, it receives an object
+		 * and the properties of that objects are assigned to the template, where
+		 * the variables in the template represent keys within the object itself.
+		 *
+		 * @param 	values 	An object of properties mapped to template variables
+		 */
+		apply: function(values) {
+			if (this.options.compile) {
+				return this.compiled(values);
+			} else {
+				var tpl = this;
+				var fm = this.helpers;
+
+				var fn = function(m, name, format, args) {
+					if (format) {
+						if (format.substr(0, 5) == "this."){
+							return tpl.call(format.substr(5), values[name], values);
+						} else {
+							if (args) {
+								// quoted values are required for strings in compiled templates, 
+								// but for non compiled we need to strip them
+								// quoted reversed for jsmin
+								var re = /^\s*['"](.*)["']\s*$/;
+								args = args.split(',');
+
+								for(var i = 0, len = args.length; i < len; i++) {
+									args[i] = args[i].replace(re, "$1");
+								}
+								args = [values[name]].concat(args);
+							} else {
+								args = [values[name]];
+							}
+
+							return fm[format].apply(fm, args);
+						}
+					} else {
+						return values[name] !== undefined ? values[name] : "";
+					}
+				};
+
+				return this.html.replace(this.options.regx, fn);
+			}
+		},
+
+		/**
+		 * Compile a template for speedier usage
+		 */
+		compile: function() {
+			var sep = $.browser.mozilla ? "+" : ",";
+			var fm = this.helpers;
+
+			var fn = function(m, name, format, args){
+				if (format) {
+					args = args ? ',' + args : "";
+
+					if (format.substr(0, 5) != "this.") {
+						format = "fm." + format + '(';
+					} else {
+						format = 'this.call("'+ format.substr(5) + '", ';
+						args = ", values";
+					}
+				} else {
+					args= ''; format = "(values['" + name + "'] == undefined ? '' : ";
+				}
+				return "'"+ sep + format + "values['" + name + "']" + args + ")"+sep+"'";
+			};
+
+			var body;
+
+			if ($.browser.mozilla) {
+				body = "this.compiled = function(values){ return '" +
+					   this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn) +
+						"';};";
+			} else {
+				body = ["this.compiled = function(values){ return ['"];
+				body.push(this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn));
+				body.push("'].join('');};");
+				body = body.join('');
+			}
+			eval(body);
+			return this;
+		}
+	});
+
+
+	/**
+	 * Save a reference in this local scope to the original methods which we're 
+	 * going to overload.
+	 **/
+	var $_old = {
+	    domManip: $.fn.domManip,
+	    text: $.fn.text,
+	    html: $.fn.html
+	};
+
+	/**
+	 * Overwrite the domManip method so that we can use things like append() by passing a 
+	 * template object and macro parameters.
+	 */
+	$.fn.domManip = function( args, table, reverse, callback ) {
+		if (args[0].isTemplate) {
+			// Apply the template and it's arguments...
+			args[0] = args[0].apply( args[1] );
+			// Get rid of the arguements, we don't want to pass them on
+			delete args[1];
+		}
+
+		// Call the original method
+		var r = $_old.domManip.apply(this, arguments);
+
+		return r;
+	};
+
+    /**
+     * Overwrite the html() method
+     */
+	$.fn.html = function( value , o ) {
+	    if (value && value.isTemplate) var value = value.apply( o );
+
+		var r = $_old.html.apply(this, [value]);
+
+		return r;
+	};
+	
+	/**
+	 * Overwrite the text() method
+	 */
+	$.fn.text = function( value , o ) {
+	    if (value && value.isTemplate) var value = value.apply( o );
+
+		var r = $_old.text.apply(this, [value]);
+
+		return r;
+	};
+
+})(jQuery);