From 5e6ede7682238bcb21e4629460f8dc0e0b3cb7de Mon Sep 17 00:00:00 2001 From: Leon van Kammen Date: Sat, 17 Feb 2024 12:02:07 +0000 Subject: [PATCH] bugfix: only show stats when debug + AnonToDict() for python --- dist/__pycache__/xrfragment.cpython-310.pyc | Bin 0 -> 69725 bytes dist/xrfragment.aframe.all.js | 5 +- dist/xrfragment.aframe.js | 5 +- dist/xrfragment.module.js | 1338 ++++++++++++++++++- dist/xrfragment.py | 21 +- dist/xrfragment.three.js | 5 +- dist/xrfragment.three.module.js | 5 +- src/3rd/js/index.js | 1 - src/3rd/js/three/index.js | 2 + src/xrfragment/XRF.hx | 7 + 10 files changed, 1378 insertions(+), 11 deletions(-) create mode 100644 dist/__pycache__/xrfragment.cpython-310.pyc diff --git a/dist/__pycache__/xrfragment.cpython-310.pyc b/dist/__pycache__/xrfragment.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b588b68123a82e18c368146c95cb09b0af0af00 GIT binary patch literal 69725 zcmce<3!GfXRp;OL_G5aU8jVJ8Ssu&sV{B(^$&Wa}581NiII%}gBs*d97?0+*q#2ER z#?>uZ>hvT|-AXu@L&%OZAJ9_A55 zV(<5N>fYOr>5-kV|NqSAR@benTXpKxsZ*y;ovKR_vgR)?@OoO8Dzeqm)5@? zUiR@+p2=r2Q6>r&GE@FHm3TZH~6^wuQHyCH^h1tjiLQ;`uHo&v==%8WTHeN^8{)U?N|a&c z-Wc8VY$m!1SgtSeZ(*;BCJ37#Y`nz3h20$8Lf9>(8-VY|68{#uC)!KsUQ*sv;@`q< zjcz0CHmk|2O8i^s?a>{C-a*QV68{$V>gZ0w?j-Ey68{$Vn&`EJy|#2C<=j%@-$K77 zx{J`eNV%uPzlGf$-9y+tgzYWyZ(;XF`v}`d*sUf0E$qJNe!}i2?6wmB7PdcnfUpM$ zyS>D}g*_M@AnX8Pca-?Iu!o}85%xO5UR~nf!XA!ZPuS}TyR*c!VX1;2|G;K-6j4l?D6Oc z!k!@Po)Z5S_U7m2Z(#Hv^jcP z^!9ThI6r{@9kKr*{L``jb@-o*{SV`xiT$rHZJ5iD+s)H&C`}ymzDG)r9?L{WJ{b^x z`}Ab#U^HvK$D+3b`x~PO_f4e@QHkd$&#@?&BW?0fmqT&v@h-9VP9KWKsN3Oa7w+TH zwYX12H{iZGn!|ldG>`kO(FxqCXaV=F(MjC5MP=N#M~k@ch?a1tqo;76j2!MvRKYzG zRdHvdQ@Bxd8n+ZZje9gYgL{m6pS615JAE8~E%wjhe`oBU$6t^AC-5)F{ssK+iv1_? zzdQDq@jny22i)H~y@>z4arhGcbFu#^{LjXIhyQ)Czk>h$vA>G{x!8XS|M}Q|8vh4k z|I<-$C^PFRw1o_Aus!QDsoDhsUXV0sl}zkDEn+?Di`IV zJiqYRsE6M|RE&E0?TPxLetwJ5Ks3m2Z!|=S>l#DT$IndPS6(b1JThOJtsaT+u#u~j7LGOwN9RflQRVrJ>m~iAJ8wR| zc(Qc!LTRyl^O9Rs5tWTJW*#y=lyN!Y1gk48IalE2`M_xqG-$n}da86KnVud| z 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 function(opts){ // return xrfragment lib as 'xrf' query functor (like jquery) for ( let i in xrf ) xrf.query[i] = xrf[i] + if( xrf.debug ) xrf.stats() + return xrf.query })(xrf.init) diff --git a/dist/xrfragment.aframe.js b/dist/xrfragment.aframe.js index a415202..fd545df 100644 --- a/dist/xrfragment.aframe.js +++ b/dist/xrfragment.aframe.js @@ -1,5 +1,5 @@ /* - * v0.5.1 generated at Fri Feb 16 04:36:12 PM UTC 2024 + * v0.5.1 generated at Sat Feb 17 12:00:53 PM UTC 2024 * https://xrfragment.org * SPDX-License-Identifier: MPL-2.0 */ @@ -1355,7 +1355,6 @@ xrf.init = function(opts){ console.log("add #debug=[0-9] to URL to see XR Fragment debuglog") xrf.debug = parseInt( ( document.location.hash.match(/debug=([0-9])/) || [0,'0'] )[1] ) } - if( xrf.debug != undefined ) xrf.stats() xrf.Parser.debug = xrf.debug xrf.detectCameraRig(opts) @@ -1699,6 +1698,8 @@ xrf.init = ((init) => function(opts){ // return xrfragment lib as 'xrf' query functor (like jquery) for ( let i in xrf ) xrf.query[i] = xrf[i] + if( xrf.debug ) xrf.stats() + return xrf.query })(xrf.init) diff --git a/dist/xrfragment.module.js b/dist/xrfragment.module.js index deed6b7..12ae78f 100644 --- a/dist/xrfragment.module.js +++ b/dist/xrfragment.module.js @@ -1,5 +1,10 @@ /* - * v0.5.1 generated at Fri Feb 16 04:36:12 PM UTC 2024 + * v0.5.1 generated at Sat Feb 17 12:00:53 PM UTC 2024 + * https://xrfragment.org + * SPDX-License-Identifier: MPL-2.0 + */ +/* + * v0.5.1 generated at Fri Feb 16 09:34:39 PM UTC 2024 * https://xrfragment.org * SPDX-License-Identifier: MPL-2.0 */ @@ -1334,3 +1339,1334 @@ xrfragment_XRF.isXRFScheme = new EReg("^xrf://",""); })(typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this); var xrfragment = $hx_exports["xrfragment"]; export default xrfragment; +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"] || {}; +var $estr = function() { return js_Boot.__string_rec(this,''); },$hxEnums = $hxEnums || {},$_; +function $extend(from, fields) { + var proto = Object.create(from); + for (var name in fields) proto[name] = fields[name]; + if( fields.toString !== Object.prototype.toString ) proto.toString = fields.toString; + return proto; +} +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; + } + ,matched: function(n) { + if(this.r.m != null && n >= 0 && n < this.r.m.length) { + return this.r.m[n]; + } else { + throw haxe_Exception.thrown("EReg::matched"); + } + } + ,matchedRight: function() { + if(this.r.m == null) { + throw haxe_Exception.thrown("No string matched"); + } + var sz = this.r.m.index + this.r.m[0].length; + return HxOverrides.substr(this.r.s,sz,this.r.s.length - sz); + } + ,matchedPos: function() { + if(this.r.m == null) { + throw haxe_Exception.thrown("No string matched"); + } + return { pos : this.r.m.index, len : this.r.m[0].length}; + } + ,split: function(s) { + var d = "#__delim__#"; + return s.replace(this.r,d).split(d); + } +}; +var HxOverrides = function() { }; +HxOverrides.__name__ = true; +HxOverrides.cca = function(s,index) { + var x = s.charCodeAt(index); + if(x != x) { + return undefined; + } + return x; +}; +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.getProperty = function(o,field) { + var tmp; + if(o == null) { + return null; + } else { + var tmp1; + if(o.__properties__) { + tmp = o.__properties__["get_" + field]; + tmp1 = tmp; + } else { + tmp1 = false; + } + if(tmp1) { + return o[tmp](); + } else { + return o[field]; + } + } +}; +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; +}; +Reflect.isObject = function(v) { + if(v == null) { + return false; + } + var t = typeof(v); + if(!(t == "string" || t == "object" && v.__enum__ == null)) { + if(t == "function") { + return (v.__name__ || v.__ename__) != null; + } else { + return false; + } + } else { + return true; + } +}; +Reflect.deleteField = function(o,field) { + if(!Object.prototype.hasOwnProperty.call(o,field)) { + return false; + } + delete(o[field]); + return true; +}; +Reflect.copy = function(o) { + if(o == null) { + return null; + } + var o2 = { }; + var _g = 0; + var _g1 = Reflect.fields(o); + while(_g < _g1.length) { + var f = _g1[_g]; + ++_g; + o2[f] = Reflect.field(o,f); + } + return o2; +}; +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 StringBuf = function() { + this.b = ""; +}; +StringBuf.__name__ = true; +var StringTools = function() { }; +StringTools.__name__ = true; +StringTools.isSpace = function(s,pos) { + var c = HxOverrides.cca(s,pos); + if(!(c > 8 && c < 14)) { + return c == 32; + } else { + return true; + } +}; +StringTools.ltrim = function(s) { + var l = s.length; + var r = 0; + while(r < l && StringTools.isSpace(s,r)) ++r; + if(r > 0) { + return HxOverrides.substr(s,r,l - r); + } else { + return s; + } +}; +StringTools.rtrim = function(s) { + var l = s.length; + var r = 0; + while(r < l && StringTools.isSpace(s,l - r - 1)) ++r; + if(r > 0) { + return HxOverrides.substr(s,0,l - r); + } else { + return s; + } +}; +StringTools.trim = function(s) { + return StringTools.ltrim(StringTools.rtrim(s)); +}; +StringTools.replace = function(s,sub,by) { + return s.split(sub).join(by); +}; +var haxe_Exception = function(message,previous,native) { + Error.call(this,message); + this.message = message; + this.__previousException = previous; + this.__nativeException = native != null ? native : this; +}; +haxe_Exception.__name__ = true; +haxe_Exception.caught = function(value) { + if(((value) instanceof haxe_Exception)) { + return value; + } else if(((value) instanceof Error)) { + return new haxe_Exception(value.message,null,value); + } else { + return new haxe_ValueException(value,null,value); + } +}; +haxe_Exception.thrown = function(value) { + if(((value) instanceof haxe_Exception)) { + return value.get_native(); + } else if(((value) instanceof Error)) { + return value; + } else { + var e = new haxe_ValueException(value); + return e; + } +}; +haxe_Exception.__super__ = Error; +haxe_Exception.prototype = $extend(Error.prototype,{ + unwrap: function() { + return this.__nativeException; + } + ,get_native: function() { + return this.__nativeException; + } + ,__properties__: {get_native:"get_native"} +}); +var haxe__$Template_TemplateExpr = $hxEnums["haxe._Template.TemplateExpr"] = { __ename__:true,__constructs__:null + ,OpVar: ($_=function(v) { return {_hx_index:0,v:v,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpVar",$_.__params__ = ["v"],$_) + ,OpExpr: ($_=function(expr) { return {_hx_index:1,expr:expr,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpExpr",$_.__params__ = ["expr"],$_) + ,OpIf: ($_=function(expr,eif,eelse) { return {_hx_index:2,expr:expr,eif:eif,eelse:eelse,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpIf",$_.__params__ = ["expr","eif","eelse"],$_) + ,OpStr: ($_=function(str) { return {_hx_index:3,str:str,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpStr",$_.__params__ = ["str"],$_) + ,OpBlock: ($_=function(l) { return {_hx_index:4,l:l,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpBlock",$_.__params__ = ["l"],$_) + ,OpForeach: ($_=function(expr,loop) { return {_hx_index:5,expr:expr,loop:loop,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpForeach",$_.__params__ = ["expr","loop"],$_) + ,OpMacro: ($_=function(name,params) { return {_hx_index:6,name:name,params:params,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpMacro",$_.__params__ = ["name","params"],$_) +}; +haxe__$Template_TemplateExpr.__constructs__ = [haxe__$Template_TemplateExpr.OpVar,haxe__$Template_TemplateExpr.OpExpr,haxe__$Template_TemplateExpr.OpIf,haxe__$Template_TemplateExpr.OpStr,haxe__$Template_TemplateExpr.OpBlock,haxe__$Template_TemplateExpr.OpForeach,haxe__$Template_TemplateExpr.OpMacro]; +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 haxe_Template = function(str) { + var tokens = this.parseTokens(str); + this.expr = this.parseBlock(tokens); + if(!tokens.isEmpty()) { + throw haxe_Exception.thrown("Unexpected '" + Std.string(tokens.first().s) + "'"); + } +}; +haxe_Template.__name__ = true; +haxe_Template.prototype = { + execute: function(context,macros) { + this.macros = macros == null ? { } : macros; + this.context = context; + this.stack = new haxe_ds_List(); + this.buf = new StringBuf(); + this.run(this.expr); + return this.buf.b; + } + ,resolve: function(v) { + if(v == "__current__") { + return this.context; + } + if(Reflect.isObject(this.context)) { + var value = Reflect.getProperty(this.context,v); + if(value != null || Object.prototype.hasOwnProperty.call(this.context,v)) { + return value; + } + } + var _g_head = this.stack.h; + while(_g_head != null) { + var val = _g_head.item; + _g_head = _g_head.next; + var ctx = val; + var value = Reflect.getProperty(ctx,v); + if(value != null || Object.prototype.hasOwnProperty.call(ctx,v)) { + return value; + } + } + return Reflect.field(haxe_Template.globals,v); + } + ,parseTokens: function(data) { + var tokens = new haxe_ds_List(); + while(haxe_Template.splitter.match(data)) { + var p = haxe_Template.splitter.matchedPos(); + if(p.pos > 0) { + tokens.add({ p : HxOverrides.substr(data,0,p.pos), s : true, l : null}); + } + if(HxOverrides.cca(data,p.pos) == 58) { + tokens.add({ p : HxOverrides.substr(data,p.pos + 2,p.len - 4), s : false, l : null}); + data = haxe_Template.splitter.matchedRight(); + continue; + } + var parp = p.pos + p.len; + var npar = 1; + var params = []; + var part = ""; + while(true) { + var c = HxOverrides.cca(data,parp); + ++parp; + if(c == 40) { + ++npar; + } else if(c == 41) { + --npar; + if(npar <= 0) { + break; + } + } else if(c == null) { + throw haxe_Exception.thrown("Unclosed macro parenthesis"); + } + if(c == 44 && npar == 1) { + params.push(part); + part = ""; + } else { + part += String.fromCodePoint(c); + } + } + params.push(part); + tokens.add({ p : haxe_Template.splitter.matched(2), s : false, l : params}); + data = HxOverrides.substr(data,parp,data.length - parp); + } + if(data.length > 0) { + tokens.add({ p : data, s : true, l : null}); + } + return tokens; + } + ,parseBlock: function(tokens) { + var l = new haxe_ds_List(); + while(true) { + var t = tokens.first(); + if(t == null) { + break; + } + if(!t.s && (t.p == "end" || t.p == "else" || HxOverrides.substr(t.p,0,7) == "elseif ")) { + break; + } + l.add(this.parse(tokens)); + } + if(l.length == 1) { + return l.first(); + } + return haxe__$Template_TemplateExpr.OpBlock(l); + } + ,parse: function(tokens) { + var t = tokens.pop(); + var p = t.p; + if(t.s) { + return haxe__$Template_TemplateExpr.OpStr(p); + } + if(t.l != null) { + var pe = new haxe_ds_List(); + var _g = 0; + var _g1 = t.l; + while(_g < _g1.length) { + var p1 = _g1[_g]; + ++_g; + pe.add(this.parseBlock(this.parseTokens(p1))); + } + return haxe__$Template_TemplateExpr.OpMacro(p,pe); + } + var kwdEnd = function(kwd) { + var pos = -1; + var length = kwd.length; + if(HxOverrides.substr(p,0,length) == kwd) { + pos = length; + var _g_offset = 0; + var _g_s = HxOverrides.substr(p,length,null); + while(_g_offset < _g_s.length) { + var c = _g_s.charCodeAt(_g_offset++); + if(c == 32) { + ++pos; + } else { + break; + } + } + } + return pos; + }; + var pos = kwdEnd("if"); + if(pos > 0) { + p = HxOverrides.substr(p,pos,p.length - pos); + var e = this.parseExpr(p); + var eif = this.parseBlock(tokens); + var t = tokens.first(); + var eelse; + if(t == null) { + throw haxe_Exception.thrown("Unclosed 'if'"); + } + if(t.p == "end") { + tokens.pop(); + eelse = null; + } else if(t.p == "else") { + tokens.pop(); + eelse = this.parseBlock(tokens); + t = tokens.pop(); + if(t == null || t.p != "end") { + throw haxe_Exception.thrown("Unclosed 'else'"); + } + } else { + t.p = HxOverrides.substr(t.p,4,t.p.length - 4); + eelse = this.parse(tokens); + } + return haxe__$Template_TemplateExpr.OpIf(e,eif,eelse); + } + var pos = kwdEnd("foreach"); + if(pos >= 0) { + p = HxOverrides.substr(p,pos,p.length - pos); + var e = this.parseExpr(p); + var efor = this.parseBlock(tokens); + var t = tokens.pop(); + if(t == null || t.p != "end") { + throw haxe_Exception.thrown("Unclosed 'foreach'"); + } + return haxe__$Template_TemplateExpr.OpForeach(e,efor); + } + if(haxe_Template.expr_splitter.match(p)) { + return haxe__$Template_TemplateExpr.OpExpr(this.parseExpr(p)); + } + return haxe__$Template_TemplateExpr.OpVar(p); + } + ,parseExpr: function(data) { + var l = new haxe_ds_List(); + var expr = data; + while(haxe_Template.expr_splitter.match(data)) { + var p = haxe_Template.expr_splitter.matchedPos(); + var k = p.pos + p.len; + if(p.pos != 0) { + l.add({ p : HxOverrides.substr(data,0,p.pos), s : true}); + } + var p1 = haxe_Template.expr_splitter.matched(0); + l.add({ p : p1, s : p1.indexOf("\"") >= 0}); + data = haxe_Template.expr_splitter.matchedRight(); + } + if(data.length != 0) { + var _g_offset = 0; + var _g_s = data; + while(_g_offset < _g_s.length) { + var _g1_key = _g_offset; + var _g1_value = _g_s.charCodeAt(_g_offset++); + var i = _g1_key; + var c = _g1_value; + if(c != 32) { + l.add({ p : HxOverrides.substr(data,i,null), s : true}); + break; + } + } + } + var e; + try { + e = this.makeExpr(l); + if(!l.isEmpty()) { + throw haxe_Exception.thrown(l.first().p); + } + } catch( _g ) { + var _g1 = haxe_Exception.caught(_g).unwrap(); + if(typeof(_g1) == "string") { + var s = _g1; + throw haxe_Exception.thrown("Unexpected '" + s + "' in " + expr); + } else { + throw _g; + } + } + return function() { + try { + return e(); + } catch( _g ) { + var exc = haxe_Exception.caught(_g).unwrap(); + throw haxe_Exception.thrown("Error : " + Std.string(exc) + " in " + expr); + } + }; + } + ,makeConst: function(v) { + haxe_Template.expr_trim.match(v); + v = haxe_Template.expr_trim.matched(1); + if(HxOverrides.cca(v,0) == 34) { + var str = HxOverrides.substr(v,1,v.length - 2); + return function() { + return str; + }; + } + if(haxe_Template.expr_int.match(v)) { + var i = Std.parseInt(v); + return function() { + return i; + }; + } + if(haxe_Template.expr_float.match(v)) { + var f = parseFloat(v); + return function() { + return f; + }; + } + var me = this; + return function() { + return me.resolve(v); + }; + } + ,makePath: function(e,l) { + var p = l.first(); + if(p == null || p.p != ".") { + return e; + } + l.pop(); + var field = l.pop(); + if(field == null || !field.s) { + throw haxe_Exception.thrown(field.p); + } + var f = field.p; + haxe_Template.expr_trim.match(f); + f = haxe_Template.expr_trim.matched(1); + return this.makePath(function() { + return Reflect.field(e(),f); + },l); + } + ,makeExpr: function(l) { + return this.makePath(this.makeExpr2(l),l); + } + ,skipSpaces: function(l) { + var p = l.first(); + while(p != null) { + var _g_offset = 0; + var _g_s = p.p; + while(_g_offset < _g_s.length) { + var c = _g_s.charCodeAt(_g_offset++); + if(c != 32) { + return; + } + } + l.pop(); + p = l.first(); + } + } + ,makeExpr2: function(l) { + this.skipSpaces(l); + var p = l.pop(); + this.skipSpaces(l); + if(p == null) { + throw haxe_Exception.thrown(""); + } + if(p.s) { + return this.makeConst(p.p); + } + switch(p.p) { + case "!": + var e = this.makeExpr(l); + return function() { + var v = e(); + if(v != null) { + return v == false; + } else { + return true; + } + }; + case "(": + this.skipSpaces(l); + var e1 = this.makeExpr(l); + this.skipSpaces(l); + var p1 = l.pop(); + if(p1 == null || p1.s) { + throw haxe_Exception.thrown(p1); + } + if(p1.p == ")") { + return e1; + } + this.skipSpaces(l); + var e2 = this.makeExpr(l); + this.skipSpaces(l); + var p2 = l.pop(); + this.skipSpaces(l); + if(p2 == null || p2.p != ")") { + throw haxe_Exception.thrown(p2); + } + switch(p1.p) { + case "!=": + return function() { + return e1() != e2(); + }; + case "&&": + return function() { + return e1() && e2(); + }; + case "*": + return function() { + return e1() * e2(); + }; + case "+": + return function() { + return e1() + e2(); + }; + case "-": + return function() { + return e1() - e2(); + }; + case "/": + return function() { + return e1() / e2(); + }; + case "<": + return function() { + return e1() < e2(); + }; + case "<=": + return function() { + return e1() <= e2(); + }; + case "==": + return function() { + return e1() == e2(); + }; + case ">": + return function() { + return e1() > e2(); + }; + case ">=": + return function() { + return e1() >= e2(); + }; + case "||": + return function() { + return e1() || e2(); + }; + default: + throw haxe_Exception.thrown("Unknown operation " + p1.p); + } + break; + case "-": + var e3 = this.makeExpr(l); + return function() { + return -e3(); + }; + } + throw haxe_Exception.thrown(p.p); + } + ,run: function(e) { + switch(e._hx_index) { + case 0: + var v = e.v; + var _this = this.buf; + var x = Std.string(this.resolve(v)); + _this.b += Std.string(x); + break; + case 1: + var e1 = e.expr; + var _this = this.buf; + var x = Std.string(e1()); + _this.b += Std.string(x); + break; + case 2: + var e1 = e.expr; + var eif = e.eif; + var eelse = e.eelse; + var v = e1(); + if(v == null || v == false) { + if(eelse != null) { + this.run(eelse); + } + } else { + this.run(eif); + } + break; + case 3: + var str = e.str; + this.buf.b += str == null ? "null" : "" + str; + break; + case 4: + var l = e.l; + var _g_head = l.h; + while(_g_head != null) { + var val = _g_head.item; + _g_head = _g_head.next; + var e1 = val; + this.run(e1); + } + break; + case 5: + var e1 = e.expr; + var loop = e.loop; + var v = e1(); + try { + var x = $getIterator(v); + if(x.hasNext == null) { + throw haxe_Exception.thrown(null); + } + v = x; + } catch( _g ) { + try { + if(v.hasNext == null) { + throw haxe_Exception.thrown(null); + } + } catch( _g1 ) { + throw haxe_Exception.thrown("Cannot iter on " + Std.string(v)); + } + } + this.stack.push(this.context); + var v1 = v; + var ctx = v1; + while(ctx.hasNext()) { + var ctx1 = ctx.next(); + this.context = ctx1; + this.run(loop); + } + this.context = this.stack.pop(); + break; + case 6: + var m = e.name; + var params = e.params; + var v = Reflect.field(this.macros,m); + var pl = []; + var old = this.buf; + pl.push($bind(this,this.resolve)); + var _g_head = params.h; + while(_g_head != null) { + var val = _g_head.item; + _g_head = _g_head.next; + var p = val; + if(p._hx_index == 0) { + var v1 = p.v; + pl.push(this.resolve(v1)); + } else { + this.buf = new StringBuf(); + this.run(p); + pl.push(this.buf.b); + } + } + this.buf = old; + try { + var _this = this.buf; + var x = Std.string(v.apply(this.macros,pl)); + _this.b += Std.string(x); + } catch( _g ) { + var e = haxe_Exception.caught(_g).unwrap(); + var plstr; + try { + plstr = pl.join(","); + } catch( _g1 ) { + plstr = "???"; + } + var msg = "Macro call " + m + "(" + plstr + ") failed (" + Std.string(e) + ")"; + throw haxe_Exception.thrown(msg); + } + break; + } + } +}; +var haxe_ValueException = function(value,previous,native) { + haxe_Exception.call(this,String(value),previous,native); + this.value = value; +}; +haxe_ValueException.__name__ = true; +haxe_ValueException.__super__ = haxe_Exception; +haxe_ValueException.prototype = $extend(haxe_Exception.prototype,{ + unwrap: function() { + return this.value; + } +}); +var haxe_ds_List = function() { + this.length = 0; +}; +haxe_ds_List.__name__ = true; +haxe_ds_List.prototype = { + add: function(item) { + var x = new haxe_ds__$List_ListNode(item,null); + if(this.h == null) { + this.h = x; + } else { + this.q.next = x; + } + this.q = x; + this.length++; + } + ,push: function(item) { + var x = new haxe_ds__$List_ListNode(item,this.h); + this.h = x; + if(this.q == null) { + this.q = x; + } + this.length++; + } + ,first: function() { + if(this.h == null) { + return null; + } else { + return this.h.item; + } + } + ,pop: function() { + if(this.h == null) { + return null; + } + var x = this.h.item; + this.h = this.h.next; + if(this.h == null) { + this.q = null; + } + this.length--; + return x; + } + ,isEmpty: function() { + return this.h == null; + } + ,toString: function() { + var s_b = ""; + var first = true; + var l = this.h; + s_b += "{"; + while(l != null) { + if(first) { + first = false; + } else { + s_b += ", "; + } + s_b += Std.string(Std.string(l.item)); + l = l.next; + } + s_b += "}"; + return s_b; + } +}; +var haxe_ds__$List_ListNode = function(item,next) { + this.item = item; + this.next = next; +}; +haxe_ds__$List_ListNode.__name__ = true; +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 ""; + case "object": + if(o.__enum__) { + var e = $hxEnums[o.__enum__]; + var con = e.__constructs__[o._hx_index]; + var n = con._hx_name; + if(con.__params__) { + s = s + "\t"; + return n + "(" + ((function($this) { + var $r; + var _g = []; + { + var _g1 = 0; + var _g2 = con.__params__; + while(true) { + if(!(_g1 < _g2.length)) { + break; + } + var p = _g2[_g1]; + _g1 = _g1 + 1; + _g.push(js_Boot.__string_rec(o[p],s)); + } + } + $r = _g; + return $r; + }(this))).join(",") + ")"; + } else { + return n; + } + } + 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_Filter = $hx_exports["xrfragment"]["Filter"] = function(str) { + this.q = { }; + this.str = ""; + if(str != null) { + this.parse(str); + } +}; +xrfragment_Filter.__name__ = true; +xrfragment_Filter.prototype = { + toObject: function() { + return Reflect.copy(this.q); + } + ,get: function() { + return Reflect.copy(this.q); + } + ,parse: function(str) { + var token = str.split(" "); + var q = { }; + var process = function(str,prefix) { + if(prefix == null) { + prefix = ""; + } + str = StringTools.trim(str); + var k = str.split("=")[0]; + var v = str.split("=")[1]; + var filter = { }; + if(q[prefix + k]) { + filter = q[prefix + k]; + } + if(xrfragment_XRF.isProp.match(str)) { + var oper = ""; + if(str.indexOf(">") != -1) { + oper = ">"; + } + if(str.indexOf("<") != -1) { + oper = "<"; + } + if(xrfragment_XRF.isExclude.match(k)) { + k = HxOverrides.substr(k,1,null); + } + v = HxOverrides.substr(v,oper.length,null); + if(oper.length == 0) { + oper = "="; + } + var rule = { }; + if(xrfragment_XRF.isNumber.match(v)) { + rule[oper] = parseFloat(v); + } else { + rule[oper] = v; + } + q["expr"] = rule; + } + var value = xrfragment_XRF.isDeep.match(str) ? k.split("*").length - 1 : 0; + q["deep"] = value; + var value = xrfragment_XRF.isExclude.match(str) ? false : true; + q["show"] = value; + var value = k.replace(xrfragment_XRF.operators.r,""); + q["key"] = value; + q["value"] = v; + }; + var _g = 0; + var _g1 = token.length; + while(_g < _g1) { + var i = _g++; + process(token[i]); + } + return this.q = q; + } + ,test: function(obj) { + var qualify = false; + var _g = 0; + var _g1 = Reflect.fields(obj); + while(_g < _g1.length) { + var k = _g1[_g]; + ++_g; + var v = Std.string(Reflect.field(obj,k)); + if(this.testProperty(k,v)) { + qualify = true; + } + } + var _g = 0; + var _g1 = Reflect.fields(obj); + while(_g < _g1.length) { + var k = _g1[_g]; + ++_g; + var v = Std.string(Reflect.field(obj,k)); + if(this.testProperty(k,v,true)) { + qualify = false; + } + } + return qualify; + } + ,testProperty: function(property,value,exclude) { + var conds = 0; + var fails = 0; + var qualify = 0; + var testprop = function(expr) { + conds += 1; + fails += expr ? 0 : 1; + return expr; + }; + if(this.q[value] != null) { + var v = this.q[value]; + if(v[property] != null) { + return v[property]; + } + } + if(Reflect.field(this.q,"expr")) { + var f = Reflect.field(this.q,"expr"); + if(!Reflect.field(this.q,"show")) { + if(Reflect.field(f,"!=") != null && testprop((value == null ? "null" : "" + value) == Std.string(Reflect.field(f,"!="))) && exclude) { + ++qualify; + } + } else { + if(Reflect.field(f,"*") != null && testprop(parseFloat(value) != null)) { + ++qualify; + } + if(Reflect.field(f,">") != null && testprop(parseFloat(value) >= parseFloat(Reflect.field(f,">")))) { + ++qualify; + } + if(Reflect.field(f,"<") != null && testprop(parseFloat(value) <= parseFloat(Reflect.field(f,"<")))) { + ++qualify; + } + if(Reflect.field(f,"=") != null && (testprop(value == Reflect.field(f,"=")) || testprop(parseFloat(value) == parseFloat(Reflect.field(f,"="))))) { + ++qualify; + } + } + } + return qualify > 0; + } +}; +var xrfragment_Parser = $hx_exports["xrfragment"]["Parser"] = function() { }; +xrfragment_Parser.__name__ = true; +xrfragment_Parser.parse = function(key,value,store,index) { + var Frag_h = Object.create(null); + Frag_h["#"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_PREDEFINED_VIEW | xrfragment_XRF.PV_EXECUTE; + Frag_h["src"] = xrfragment_XRF.T_URL; + Frag_h["href"] = xrfragment_XRF.T_URL | xrfragment_XRF.T_PREDEFINED_VIEW; + Frag_h["tag"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING; + Frag_h["pos"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.T_STRING | xrfragment_XRF.METADATA | xrfragment_XRF.NAVIGATOR; + Frag_h["rot"] = xrfragment_XRF.QUERY_OPERATOR | xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.METADATA | xrfragment_XRF.NAVIGATOR; + Frag_h["t"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_FLOAT | xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.NAVIGATOR | xrfragment_XRF.METADATA; + Frag_h["s"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_MEDIAFRAG; + Frag_h["loop"] = xrfragment_XRF.PV_OVERRIDE; + Frag_h["uv"] = xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.T_MEDIAFRAG; + Frag_h["namespace"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING; + Frag_h["SPDX"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING; + Frag_h["unit"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING; + Frag_h["description"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING; + var keyStripped = key.replace(xrfragment_XRF.operators.r,""); + var isPVDynamic = key.length > 0 && !Object.prototype.hasOwnProperty.call(Frag_h,key); + if(isPVDynamic) { + var v = new xrfragment_XRF(key,xrfragment_XRF.PV_EXECUTE | xrfragment_XRF.NAVIGATOR,index); + v.validate(value); + v.flags = xrfragment_XRF.set(xrfragment_XRF.T_DYNAMICKEY,v.flags); + if(!Object.prototype.hasOwnProperty.call(Frag_h,key)) { + v.flags = xrfragment_XRF.set(xrfragment_XRF.CUSTOMFRAG,v.flags); + } + if(value.length == 0) { + v.flags = xrfragment_XRF.set(xrfragment_XRF.T_DYNAMICKEYVALUE,v.flags); + } + store[keyStripped] = v; + return true; + } + var v = new xrfragment_XRF(key,Frag_h[key],index); + if(Object.prototype.hasOwnProperty.call(Frag_h,key)) { + if(!v.validate(value)) { + console.log("src/xrfragment/Parser.hx:67:","⚠ fragment '" + key + "' has incompatible value (" + value + ")"); + return false; + } + store[keyStripped] = v; + if(xrfragment_Parser.debug) { + console.log("src/xrfragment/Parser.hx:71:","✔ " + key + ": " + v.string); + } + } else { + if(typeof(value) == "string") { + v.guessType(v,value); + } + v.flags = xrfragment_XRF.set(xrfragment_XRF.CUSTOMFRAG,v.flags); + store[keyStripped] = v; + } + return true; +}; +var xrfragment_URI = $hx_exports["xrfragment"]["URI"] = function() { }; +xrfragment_URI.__name__ = true; +xrfragment_URI.parse = function(url,filter) { + var store = { }; + if(url == null || url.indexOf("#") == -1) { + return store; + } + var fragment = url.split("#"); + var splitArray = fragment[1].split("&"); + var _g = 0; + var _g1 = splitArray.length; + while(_g < _g1) { + var i = _g++; + var splitByEqual = splitArray[i].split("="); + var regexPlus = new EReg("\\+","g"); + var key = splitByEqual[0]; + var value = ""; + if(splitByEqual.length > 1) { + if(xrfragment_XRF.isVector.match(splitByEqual[1])) { + value = splitByEqual[1]; + } else { + var s = regexPlus.split(splitByEqual[1]).join(" "); + value = decodeURIComponent(s.split("+").join(" ")); + } + } + var ok = xrfragment_Parser.parse(key,value,store,i); + } + if(filter != null && filter != 0) { + var _g = 0; + var _g1 = Reflect.fields(store); + while(_g < _g1.length) { + var key = _g1[_g]; + ++_g; + var xrf = store[key]; + if(!xrf.is(filter)) { + Reflect.deleteField(store,key); + } + } + } + return store; +}; +xrfragment_URI.template = function(uri,vars) { + var parts = uri.split("#"); + if(parts.length == 1) { + return uri; + } + var frag = parts[1]; + frag = StringTools.replace(frag,"{","::"); + frag = StringTools.replace(frag,"}","::"); + frag = new haxe_Template(frag).execute(vars); + frag = StringTools.replace(frag,"null",""); + parts[1] = frag; + return parts.join("#"); +}; +var xrfragment_XRF = $hx_exports["xrfragment"]["XRF"] = function(_fragment,_flags,_index) { + this.floats = []; + this.shift = []; + this.fragment = _fragment; + this.flags = _flags; + this.index = _index; +}; +xrfragment_XRF.__name__ = true; +xrfragment_XRF.set = function(flag,flags) { + return flags | flag; +}; +xrfragment_XRF.unset = function(flag,flags) { + return flags & ~flag; +}; +xrfragment_XRF.prototype = { + is: function(flag) { + var v = this.flags; + if(!(typeof(v) == "number" && ((v | 0) === v))) { + this.flags = 0; + } + return (this.flags & flag) != 0; + } + ,validate: function(value) { + this.guessType(this,value); + var ok = true; + if(!this.is(xrfragment_XRF.T_FLOAT) && this.is(xrfragment_XRF.T_VECTOR2) && !(typeof(this.x) == "number" && typeof(this.y) == "number")) { + ok = false; + } + if(!(this.is(xrfragment_XRF.T_VECTOR2) || this.is(xrfragment_XRF.T_STRING)) && this.is(xrfragment_XRF.T_VECTOR3) && !(typeof(this.x) == "number" && typeof(this.y) == "number" && typeof(this.z) == "number")) { + ok = false; + } + return ok; + } + ,guessType: function(v,str) { + v.string = str; + if(xrfragment_XRF.isReset.match(v.fragment)) { + v.reset = true; + } + if(v.fragment == "loop") { + v.loop = true; + } + if(typeof(str) != "string") { + return; + } + if(str.length > 0) { + if(xrfragment_XRF.isXRFScheme.match(str)) { + v.xrfScheme = true; + str = str.replace(xrfragment_XRF.isXRFScheme.r,""); + v.string = str; + } + if(str.split(",").length > 1) { + var xyzn = str.split(","); + if(xyzn.length > 0) { + v.x = parseFloat(xyzn[0]); + } + if(xyzn.length > 1) { + v.y = parseFloat(xyzn[1]); + } + if(xyzn.length > 2) { + v.z = parseFloat(xyzn[2]); + } + var _g = 0; + var _g1 = xyzn.length; + while(_g < _g1) { + var i = _g++; + v.shift.push(xrfragment_XRF.isShift.match(xyzn[i])); + v.floats.push(parseFloat(xyzn[i].replace(xrfragment_XRF.isShift.r,""))); + } + } + if(xrfragment_XRF.isColor.match(str)) { + v.color = str; + } + if(xrfragment_XRF.isFloat.match(str)) { + v.x = parseFloat(str); + v.float = v.x; + } + if(xrfragment_XRF.isInt.match(str)) { + v.int = Std.parseInt(str); + v.x = v.int; + v.floats.push(v.x); + } + v.filter = new xrfragment_Filter(v.fragment + "=" + v.string); + } else { + v.filter = new xrfragment_Filter(v.fragment); + } + } +}; +function $getIterator(o) { if( o instanceof Array ) return new haxe_iterators_ArrayIterator(o); else return o.iterator(); } +function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $global.$haxeUID++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = m.bind(o); o.hx__closures__[m.__id__] = f; } return f; } +$global.$haxeUID |= 0; +if(typeof(performance) != "undefined" ? typeof(performance.now) == "function" : false) { + HxOverrides.now = performance.now.bind(performance); +} +if( String.fromCodePoint == null ) String.fromCodePoint = function(c) { return c < 0x10000 ? String.fromCharCode(c) : String.fromCharCode((c>>10)+0xD7C0)+String.fromCharCode((c&0x3FF)+0xDC00); } +String.__name__ = true; +Array.__name__ = true; +js_Boot.__toStr = ({ }).toString; +haxe_Template.splitter = new EReg("(::[A-Za-z0-9_ ()&|!+=/><*.\"-]+::|\\$\\$([A-Za-z0-9_-]+)\\()",""); +haxe_Template.expr_splitter = new EReg("(\\(|\\)|[ \r\n\t]*\"[^\"]*\"[ \r\n\t]*|[!+=/><*.&|-]+)",""); +haxe_Template.expr_trim = new EReg("^[ ]*([^ ]+)[ ]*$",""); +haxe_Template.expr_int = new EReg("^[0-9]+$",""); +haxe_Template.expr_float = new EReg("^([+-]?)(?=\\d|,\\d)\\d*(,\\d*)?([Ee]([+-]?\\d+))?$",""); +haxe_Template.globals = { }; +haxe_Template.hxKeepArrayIterator = new haxe_iterators_ArrayIterator([]); +xrfragment_Parser.error = ""; +xrfragment_Parser.debug = false; +xrfragment_URI.__meta__ = { statics : { template : { keep : null}}}; +xrfragment_XRF.IMMUTABLE = 1; +xrfragment_XRF.PROP_BIND = 2; +xrfragment_XRF.QUERY_OPERATOR = 4; +xrfragment_XRF.PROMPT = 8; +xrfragment_XRF.CUSTOMFRAG = 16; +xrfragment_XRF.NAVIGATOR = 32; +xrfragment_XRF.METADATA = 64; +xrfragment_XRF.PV_OVERRIDE = 128; +xrfragment_XRF.PV_EXECUTE = 256; +xrfragment_XRF.T_COLOR = 8192; +xrfragment_XRF.T_INT = 16384; +xrfragment_XRF.T_FLOAT = 32768; +xrfragment_XRF.T_VECTOR2 = 65536; +xrfragment_XRF.T_VECTOR3 = 131072; +xrfragment_XRF.T_URL = 262144; +xrfragment_XRF.T_PREDEFINED_VIEW = 524288; +xrfragment_XRF.T_STRING = 1048576; +xrfragment_XRF.T_MEDIAFRAG = 2097152; +xrfragment_XRF.T_DYNAMICKEY = 4194304; +xrfragment_XRF.T_DYNAMICKEYVALUE = 8388608; +xrfragment_XRF.isColor = new EReg("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$",""); +xrfragment_XRF.isInt = new EReg("^[-0-9]+$",""); +xrfragment_XRF.isFloat = new EReg("^[-0-9]+\\.[0-9]+$",""); +xrfragment_XRF.isVector = new EReg("([,]+|\\w)",""); +xrfragment_XRF.isUrl = new EReg("(://)?\\..*",""); +xrfragment_XRF.isUrlOrPretypedView = new EReg("(^#|://)?\\..*",""); +xrfragment_XRF.isString = new EReg(".*",""); +xrfragment_XRF.operators = new EReg("(^[-]|^[!]|[\\*]$)","g"); +xrfragment_XRF.isProp = new EReg("^.*=[><=]?",""); +xrfragment_XRF.isExclude = new EReg("^-",""); +xrfragment_XRF.isDeep = new EReg("\\*",""); +xrfragment_XRF.isNumber = new EReg("^[0-9\\.]+$",""); +xrfragment_XRF.isMediaFrag = new EReg("^([0-9\\.,\\*+-]+)$",""); +xrfragment_XRF.isReset = new EReg("^!",""); +xrfragment_XRF.isShift = new EReg("^(\\+|--)",""); +xrfragment_XRF.isXRFScheme = new EReg("^xrf://",""); +})(typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this); +var xrfragment = $hx_exports["xrfragment"]; +export default xrfragment; diff --git a/dist/xrfragment.py b/dist/xrfragment.py index 0f22456..4289c9d 100644 --- a/dist/xrfragment.py +++ b/dist/xrfragment.py @@ -1767,6 +1767,20 @@ class python_HaxeIterator: python_HaxeIterator._hx_class = python_HaxeIterator +class python_Lib: + _hx_class_name = "python.Lib" + __slots__ = () + _hx_statics = ["anonToDict"] + + @staticmethod + def anonToDict(o): + if isinstance(o,_hx_AnonObject): + return o.__dict__.copy() + else: + return None +python_Lib._hx_class = python_Lib + + class python_internal_ArrayImpl: _hx_class_name = "python.internal.ArrayImpl" __slots__ = () @@ -2351,7 +2365,7 @@ class xrfragment_XRF: __slots__ = ("fragment", "flags", "index", "x", "y", "z", "shift", "floats", "color", "string", "int", "float", "filter", "reset", "loop", "xrfScheme") _hx_fields = ["fragment", "flags", "index", "x", "y", "z", "shift", "floats", "color", "string", "int", "float", "filter", "reset", "loop", "xrfScheme"] _hx_methods = ["is", "validate", "guessType"] - _hx_statics = ["IMMUTABLE", "PROP_BIND", "QUERY_OPERATOR", "PROMPT", "CUSTOMFRAG", "NAVIGATOR", "METADATA", "PV_OVERRIDE", "PV_EXECUTE", "T_COLOR", "T_INT", "T_FLOAT", "T_VECTOR2", "T_VECTOR3", "T_URL", "T_PREDEFINED_VIEW", "T_STRING", "T_MEDIAFRAG", "T_DYNAMICKEY", "T_DYNAMICKEYVALUE", "isColor", "isInt", "isFloat", "isVector", "isUrl", "isUrlOrPretypedView", "isString", "operators", "isProp", "isExclude", "isDeep", "isNumber", "isMediaFrag", "isReset", "isShift", "isXRFScheme", "set", "unset"] + _hx_statics = ["__meta__", "IMMUTABLE", "PROP_BIND", "QUERY_OPERATOR", "PROMPT", "CUSTOMFRAG", "NAVIGATOR", "METADATA", "PV_OVERRIDE", "PV_EXECUTE", "T_COLOR", "T_INT", "T_FLOAT", "T_VECTOR2", "T_VECTOR3", "T_URL", "T_PREDEFINED_VIEW", "T_STRING", "T_MEDIAFRAG", "T_DYNAMICKEY", "T_DYNAMICKEYVALUE", "isColor", "isInt", "isFloat", "isVector", "isUrl", "isUrlOrPretypedView", "isString", "operators", "isProp", "isExclude", "isDeep", "isNumber", "isMediaFrag", "isReset", "isShift", "isXRFScheme", "set", "unset", "toDict"] def __init__(self,_fragment,_flags,_index = None): self.xrfScheme = None @@ -2452,6 +2466,10 @@ class xrfragment_XRF: def unset(flag,flags): return (flags & ~flag) + @staticmethod + def toDict(o): + return python_Lib.anonToDict(o) + xrfragment_XRF._hx_class = xrfragment_XRF Math.NEGATIVE_INFINITY = float("-inf") @@ -2471,6 +2489,7 @@ python_Boot.prefixLength = len("_hx_") xrfragment_Parser.error = "" xrfragment_Parser.debug = False xrfragment_URI.__meta__ = _hx_AnonObject({'statics': _hx_AnonObject({'template': _hx_AnonObject({'keep': None})})}) +xrfragment_XRF.__meta__ = _hx_AnonObject({'statics': _hx_AnonObject({'toDict': _hx_AnonObject({'keep': None})})}) xrfragment_XRF.IMMUTABLE = 1 xrfragment_XRF.PROP_BIND = 2 xrfragment_XRF.QUERY_OPERATOR = 4 diff --git a/dist/xrfragment.three.js b/dist/xrfragment.three.js index 860d58c..9fa4411 100644 --- a/dist/xrfragment.three.js +++ b/dist/xrfragment.three.js @@ -1,5 +1,5 @@ /* - * v0.5.1 generated at Fri Feb 16 04:36:12 PM UTC 2024 + * v0.5.1 generated at Sat Feb 17 12:00:53 PM UTC 2024 * https://xrfragment.org * SPDX-License-Identifier: MPL-2.0 */ @@ -1355,7 +1355,6 @@ xrf.init = function(opts){ console.log("add #debug=[0-9] to URL to see XR Fragment debuglog") xrf.debug = parseInt( ( document.location.hash.match(/debug=([0-9])/) || [0,'0'] )[1] ) } - if( xrf.debug != undefined ) xrf.stats() xrf.Parser.debug = xrf.debug xrf.detectCameraRig(opts) @@ -1699,6 +1698,8 @@ xrf.init = ((init) => function(opts){ // return xrfragment lib as 'xrf' query functor (like jquery) for ( let i in xrf ) xrf.query[i] = xrf[i] + if( xrf.debug ) xrf.stats() + return xrf.query })(xrf.init) diff --git a/dist/xrfragment.three.module.js b/dist/xrfragment.three.module.js index 1350052..5f6c41d 100644 --- a/dist/xrfragment.three.module.js +++ b/dist/xrfragment.three.module.js @@ -1,5 +1,5 @@ /* - * v0.5.1 generated at Fri Feb 16 04:36:12 PM UTC 2024 + * v0.5.1 generated at Sat Feb 17 12:00:53 PM UTC 2024 * https://xrfragment.org * SPDX-License-Identifier: MPL-2.0 */ @@ -1355,7 +1355,6 @@ xrf.init = function(opts){ console.log("add #debug=[0-9] to URL to see XR Fragment debuglog") xrf.debug = parseInt( ( document.location.hash.match(/debug=([0-9])/) || [0,'0'] )[1] ) } - if( xrf.debug != undefined ) xrf.stats() xrf.Parser.debug = xrf.debug xrf.detectCameraRig(opts) @@ -1699,6 +1698,8 @@ xrf.init = ((init) => function(opts){ // return xrfragment lib as 'xrf' query functor (like jquery) for ( let i in xrf ) xrf.query[i] = xrf[i] + if( xrf.debug ) xrf.stats() + return xrf.query })(xrf.init) diff --git a/src/3rd/js/index.js b/src/3rd/js/index.js index 7eb4ff6..068d034 100644 --- a/src/3rd/js/index.js +++ b/src/3rd/js/index.js @@ -11,7 +11,6 @@ xrf.init = function(opts){ console.log("add #debug=[0-9] to URL to see XR Fragment debuglog") xrf.debug = parseInt( ( document.location.hash.match(/debug=([0-9])/) || [0,'0'] )[1] ) } - if( xrf.debug != undefined ) xrf.stats() xrf.Parser.debug = xrf.debug xrf.detectCameraRig(opts) diff --git a/src/3rd/js/three/index.js b/src/3rd/js/three/index.js index 7961efe..588dd23 100644 --- a/src/3rd/js/three/index.js +++ b/src/3rd/js/three/index.js @@ -14,6 +14,8 @@ xrf.init = ((init) => function(opts){ // return xrfragment lib as 'xrf' query functor (like jquery) for ( let i in xrf ) xrf.query[i] = xrf[i] + if( xrf.debug ) xrf.stats() + return xrf.query })(xrf.init) diff --git a/src/xrfragment/XRF.hx b/src/xrfragment/XRF.hx index 7494d6b..08020ef 100644 --- a/src/xrfragment/XRF.hx +++ b/src/xrfragment/XRF.hx @@ -141,4 +141,11 @@ class XRF { }else v.filter = new Filter(v.fragment); } + #if python + @keep + public static function toDict(o:{}){ + return python.Lib.anonToDict(o); + } + #end + }