xrfragment/test/generated/test.js

var $hx_exports = typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this;
(function ($global) { "use strict";
$hx_exports["xrfragment"] = $hx_exports["xrfragment"] || {};
$hx_exports["xrfragment"]["Query"] = $hx_exports["xrfragment"]["Query"] || {};
var EReg = function(r,opt) {
	this.r = new RegExp(r,opt.split("u").join(""));
};
EReg.__name__ = true;
EReg.prototype = {
	match: function(s) {
		if(this.r.global) {
			this.r.lastIndex = 0;
		}
		this.r.m = this.r.exec(s);
		this.r.s = s;
		return this.r.m != null;
	}
	,split: function(s) {
		var d = "#__delim__#";
		return s.replace(this.r,d).split(d);
	}
};
var HxOverrides = function() { };
HxOverrides.__name__ = true;
HxOverrides.substr = function(s,pos,len) {
	if(len == null) {
		len = s.length;
	} else if(len < 0) {
		if(pos == 0) {
			len = s.length + len;
		} else {
			return "";
		}
	}
	return s.substr(pos,len);
};
HxOverrides.now = function() {
	return Date.now();
};
Math.__name__ = true;
var Reflect = function() { };
Reflect.__name__ = true;
Reflect.field = function(o,field) {
	try {
		return o[field];
	} catch( _g ) {
		return null;
	}
};
Reflect.fields = function(o) {
	var a = [];
	if(o != null) {
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		for( var f in o ) {
		if(f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o,f)) {
			a.push(f);
		}
		}
	}
	return a;
};
var Std = function() { };
Std.__name__ = true;
Std.string = function(s) {
	return js_Boot.__string_rec(s,"");
};
Std.parseInt = function(x) {
	if(x != null) {
		var _g = 0;
		var _g1 = x.length;
		while(_g < _g1) {
			var i = _g++;
			var c = x.charCodeAt(i);
			if(c <= 8 || c >= 14 && c != 32 && c != 45) {
				var nc = x.charCodeAt(i + 1);
				var v = parseInt(x,nc == 120 || nc == 88 ? 16 : 10);
				if(isNaN(v)) {
					return null;
				} else {
					return v;
				}
			}
		}
	}
	return null;
};
var Test = function() { };
Test.__name__ = true;
Test.main = function() {
	Test.test([{ fn : "query", expect : { fn : "selected", input : "foo", out : true}, data : "foo or bar"},{ fn : "query", expect : { fn : "selected", input : "xxx", out : false}, label : "nonselected entity", data : "foo or bar"}]);
	Test.test([{ fn : "url", expect : { fn : "equal.string", input : "bar", out : "flop"}, data : "http://foo.com?foo=1#bar=flop&a=1,2&b=c|d|1,2,3"},{ fn : "url", expect : { fn : "equal.xy", input : "a", out : "1.22.2"}, label : "a equal.xy", data : "http://foo.com?foo=1#bar=flop&a=1.2,2.2&b=c|d|1,2,3"},{ fn : "url", expect : { fn : "equal.multi", input : "b", out : "c|d|1,2,3"}, label : "b equal.multi", data : "http://foo.com?foo=1#b=c|d|1,2,3"}]);
};
Test.test = function(spec) {
	var Query = xrfragment_Query;
	var errors = 0;
	var _g = 0;
	var _g1 = spec.length;
	while(_g < _g1) {
		var i = _g++;
		var q = null;
		var res = null;
		var valid = false;
		var item = spec[i];
		if(item.fn == "query") {
			q = new xrfragment_Query(item.data);
		}
		if(item.fn == "url") {
			res = xrfragment_Url.parse(item.data);
		}
		if(item.expect.fn == "selected") {
			valid = item.expect.out == q.selected(item.expect.input);
		}
		if(item.expect.fn == "equal.string") {
			valid = item.expect.out == res[item.expect.input].string;
		}
		if(item.expect.fn == "equal.xy") {
			valid = item.expect.out == Std.string(res[item.expect.input].x) + Std.string(res[item.expect.input].y);
		}
		if(item.expect.fn == "equal.multi") {
			valid = Test.equalMulti(res,item);
		}
		var ok = valid ? "[ ✔ ] " : "[ ❌] ";
		console.log("src/Test.hx:34:",ok + Std.string(item.fn) + ": '" + Std.string(item.data) + "'" + (item.label ? " <= " + (item.label ? item.label : item.expect.fn) : ""));
		if(!valid) {
			++errors;
		}
	}
	if(errors > 1) {
		console.log("src/Test.hx:37:","\n-----\n[ ❌] " + errors + " errors :/");
	}
};
Test.equalMulti = function(res,item) {
	var target = res[item.expect.input];
	var str = "";
	var _g = 0;
	var _g1 = target.args.length;
	while(_g < _g1) {
		var i = _g++;
		str = str + "|" + target.args[i].string;
	}
	str = HxOverrides.substr(str,1,null);
	return str == item.expect.out;
};
var haxe_iterators_ArrayIterator = function(array) {
	this.current = 0;
	this.array = array;
};
haxe_iterators_ArrayIterator.__name__ = true;
haxe_iterators_ArrayIterator.prototype = {
	hasNext: function() {
		return this.current < this.array.length;
	}
	,next: function() {
		return this.array[this.current++];
	}
};
var js_Boot = function() { };
js_Boot.__name__ = true;
js_Boot.__string_rec = function(o,s) {
	if(o == null) {
		return "null";
	}
	if(s.length >= 5) {
		return "<...>";
	}
	var t = typeof(o);
	if(t == "function" && (o.__name__ || o.__ename__)) {
		t = "object";
	}
	switch(t) {
	case "function":
		return "<function>";
	case "object":
		if(((o) instanceof Array)) {
			var str = "[";
			s += "\t";
			var _g = 0;
			var _g1 = o.length;
			while(_g < _g1) {
				var i = _g++;
				str += (i > 0 ? "," : "") + js_Boot.__string_rec(o[i],s);
			}
			str += "]";
			return str;
		}
		var tostr;
		try {
			tostr = o.toString;
		} catch( _g ) {
			return "???";
		}
		if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
			var s2 = o.toString();
			if(s2 != "[object Object]") {
				return s2;
			}
		}
		var str = "{\n";
		s += "\t";
		var hasp = o.hasOwnProperty != null;
		var k = null;
		for( k in o ) {
		if(hasp && !o.hasOwnProperty(k)) {
			continue;
		}
		if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
			continue;
		}
		if(str.length != 2) {
			str += ", \n";
		}
		str += s + k + " : " + js_Boot.__string_rec(o[k],s);
		}
		s = s.substring(1);
		str += "\n" + s + "}";
		return str;
	case "string":
		return o;
	default:
		return String(o);
	}
};
var xrfragment_Query = function(str) {
	this.preset = "";
	this.accept = false;
	this.exclude = [];
	this.include = [];
	this.q = { };
	if(str != null) {
		this.parse(str);
	}
};
xrfragment_Query.__name__ = true;
xrfragment_Query.prototype = {
	selected: function(nodename) {
		if(this.q.copy_all) {
			this.accept = true;
		}
		if(this.include.indexOf(nodename) != -1) {
			this.accept = true;
		}
		if(this.exclude.indexOf(nodename) != -1) {
			this.accept = false;
		}
		return this.accept;
	}
	,parse: function(str,recurse) {
		if(recurse == null) {
			recurse = false;
		}
		var _gthis = this;
		var copyAll = recurse ? this.q.copy_all : HxOverrides.substr(str,0,1) == "-" || HxOverrides.substr(str,0,1) == "?" || str == "";
		var isOr = new EReg("^or$","");
		var isProp = new EReg(".*:[><=!]?","");
		var isName = new EReg("[^:/]","");
		var isExclude = new EReg("^-","");
		var isInclude = new EReg("^\\+","");
		var isPreset = new EReg("^\\?","");
		var token = str.split(" ");
		var ors = [];
		var q = { };
		var composeQuery = function() {
			q = { };
			var value = [];
			q["object"] = value;
			var value = [];
			q["-object"] = value;
			ors.push(q);
			return q;
		};
		composeQuery();
		var match = null;
		match = function(str,prefix) {
			if(prefix == null) {
				prefix = "";
			}
			if(isPreset.match(str) && !recurse) {
				_gthis.preset = str;
				return;
			}
			if(isExclude.match(str) || isInclude.match(str)) {
				var t = HxOverrides.substr(str,1,null);
				match(t,HxOverrides.substr(str,0,1));
				return;
			}
			if(isProp.match(str)) {
				var skip = 0;
				var type = "=";
				if(str.indexOf("*") != -1) {
					type = "*";
				}
				if(str.indexOf(">") != -1) {
					type = ">";
				}
				if(str.indexOf("<") != -1) {
					type = "<";
				}
				if(str.indexOf("!=") != -1) {
					type = "!=";
				}
				if(str.indexOf(">=") != -1) {
					type = ">=";
				}
				if(str.indexOf("<=") != -1) {
					type = "<=";
				}
				if(type != "=") {
					skip += type.length;
				}
				var property = str.split(":")[0];
				var value;
				if(q[prefix + property]) {
					value = q[prefix + property];
				} else {
					value = { };
				}
				value[type] = HxOverrides.substr(str.split(":")[1],skip,null);
				q[prefix + property] = value;
				return;
			}
			if(isName.match(str)) {
				if(prefix == "-") {
					q["-object"].push(str);
					while(q["object"].contains(str) == true) q["object"].remove(str);
				} else {
					q["object"].push(str);
					while(q["-object"].contains(str) == true) q["-object"].remove(str);
				}
				return;
			}
		};
		var _g = 0;
		var _g1 = token.length;
		while(_g < _g1) {
			var i = _g++;
			if(isOr.match(token[i])) {
				composeQuery();
			} else {
				match(token[i]);
			}
		}
		var _g = 0;
		var _g1 = ors.length;
		while(_g < _g1) {
			var i = _g++;
			var or = ors[i];
			if(Reflect.field(or,"object") != null) {
				this.include = this.include.concat(Reflect.field(or,"object"));
			}
			if(Reflect.field(or,"-object") != null) {
				this.exclude = this.exclude.concat(Reflect.field(or,"-object"));
			}
		}
		this.q = { or : ors, copy_all : copyAll};
		return this.q;
	}
	,test: function(property,value) {
		if(this.preset == property) {
			this.parse(value,true);
		}
		var _g = 0;
		var _g1 = this.q.or.length;
		while(_g < _g1) {
			var i = _g++;
			var or = this.q.or[i];
			var conds = [0];
			var fails = [0];
			var pass = 0;
			var when = (function(fails,conds) {
				return function(expr) {
					conds[0] += 1;
					fails[0] += expr ? 0 : 1;
					return expr;
				};
			})(fails,conds);
			var _g2 = 0;
			var _g3 = Reflect.fields(or);
			while(_g2 < _g3.length) {
				var k = _g3[_g2];
				++_g2;
				var orval = Reflect.field(or,k);
				if(k != property) {
					continue;
				}
				if(Reflect.field(orval,"=") != null && when(value == Reflect.field(orval,"="))) {
					++pass;
				}
				if(Reflect.field(orval,"*") != null && when(value != null)) {
					++pass;
				}
				if(Reflect.field(orval,">") != null && when(value > Std.parseInt(Reflect.field(orval,">")))) {
					++pass;
				}
				if(Reflect.field(orval,"<") != null && when(value < Std.parseInt(Reflect.field(orval,"<")))) {
					++pass;
				}
				if(Reflect.field(orval,">=") != null && when(value >= Std.parseInt(Reflect.field(orval,">=")))) {
					++pass;
				}
				if(Reflect.field(orval,"<=") != null && when(value >= Std.parseInt(Reflect.field(orval,"<=")))) {
					++pass;
				}
				if(Reflect.field(orval,"!=") != null && when(value != Std.parseInt(Reflect.field(orval,"!=")))) {
					++pass;
				}
			}
			if(this.accept && conds[0] > 0 && fails[0] > 0) {
				this.accept = false;
			}
			if(conds[0] > 0 && pass > 0 && fails[0] == 0) {
				this.accept = true;
			}
		}
	}
};
var xrfragment_Value = $hx_exports["xrfragment"]["Value"] = function() {
};
xrfragment_Value.__name__ = true;
var xrfragment_Url = function() { };
xrfragment_Url.__name__ = true;
xrfragment_Url.parse = function(qs) {
	var fragment = qs.split("#");
	var splitArray = fragment[1].split("&");
	var regexPlus = new EReg("\\+","g");
	var resultMap = { };
	var _g = 0;
	var _g1 = splitArray.length;
	while(_g < _g1) {
		var i = _g++;
		var splitByEqual = splitArray[i].split("=");
		var key = splitByEqual[0];
		var v = new xrfragment_Value();
		if(splitByEqual.length > 1) {
			var s = regexPlus.split(splitByEqual[1]).join(" ");
			var value = decodeURIComponent(s.split("+").join(" "));
			xrfragment_Url.guessType(v,value);
			if(value.split("|").length > 1) {
				v.args = [];
				var args = value.split("|");
				var _g2 = 0;
				var _g3 = args.length;
				while(_g2 < _g3) {
					var i1 = _g2++;
					var x = new xrfragment_Value();
					xrfragment_Url.guessType(x,args[i1]);
					v.args.push(x);
				}
			}
			resultMap[key] = v;
		}
	}
	return resultMap;
};
xrfragment_Url.guessType = function(v,str) {
	var isColor = new EReg("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$","");
	var isInt = new EReg("^[0-9]+$","");
	var isFloat = new EReg("^[0-9]+\\.[0-9]+$","");
	v.string = str;
	if(str.split(",").length > 1) {
		var xyz = str.split(",");
		if(xyz.length > 0) {
			v.x = parseFloat(xyz[0]);
		}
		if(xyz.length > 1) {
			v.y = parseFloat(xyz[1]);
		}
		if(xyz.length > 2) {
			v.z = parseFloat(xyz[2]);
		}
	}
	if(isColor.match(str)) {
		v.color = str;
	}
	if(isFloat.match(str)) {
		v.float = parseFloat(str);
	}
	if(isInt.match(str)) {
		v.int = Std.parseInt(str);
	}
};
if(typeof(performance) != "undefined" ? typeof(performance.now) == "function" : false) {
	HxOverrides.now = performance.now.bind(performance);
}
String.__name__ = true;
Array.__name__ = true;
js_Boot.__toStr = ({ }).toString;
var xrfragment_Query_ok = $hx_exports["xrfragment"]["Query"]["ok"] = 
    // haxe workarounds
    Array.prototype.contains = Array.prototype.includes

    if (typeof Array.prototype.remove !== "function") {
      Array.prototype.remove = function (item) {
        const oldLength = this.length
        let newLength = 0

        for (let i = 0; i < oldLength; i++) {
          const entry = this[i]
          if (entry === item) {
            let newLength = i++

            while (i !== this.length) {
              const entry = this[i]
              if (entry !== item) this[newLength++] = entry
              i++
            }

            this.length = newLength
            for (let i = newLength; i < oldLength; i++) delete this[i]
            return true
          }
        }
        return false
      }
    }
  ;
Test.main();
})({});
var xrfragment = $hx_exports["xrfragment"];