templating changes

js_client/jsync_lib.js

 "use strict";
 
+// makestache template info 
+// the following string tells my make scripts its fine to overwtite this the library would have had a template str in the middle of the str
+// BUILT_FILE_OVERWRITE_ALLOWED
+//  ... C:\ws\repos\jitsi_main\jsync\jsyncdb\js_client\jsync_lib.js
+// /* */ 
+
 (function (){
 var isProxy,tlu,msto_z
 var pf,msto_prx
 	clog("WS_CLOSE",{that:this,readyState:this.readyState,args:[...arguments]})
 	// glob_u.ws.sockets.ws1.params.ord.run_cbs("WS_CLOSE:",{event,that:this})
 	glob_u.ws.sockets[this.params.socket_name].params.ord.run_cbs("WS_CLOSE:",{event,that:this})
-	let  timeout0 = this.params.timeout0 || 100
-	let timeout_multi = this.params.timeout_multi || 3000
-	let t =timeout_multi
-	// let now = Date.now()
-	if (this.params.HAS_OPENED && timeout_multi<Date.now()-this.params.OPEN_TIME){
-		t=timeout0
-	}
-	// clog(":TIME:",now,this.params.OPEN_TIME,now-this.params.OPEN_TIME)
-	this.params.HAS_OPENED = 0
-	setTimeout(this.params.fns.reconnect,t)
+	setTimeout(this.params.fns.reconnect,1000)
 }
 
 window.glob_u.ws.fns.onmessage = function onmessage(event){
 
 }
 window.glob_u.ws.fns.onopen = function onopen(event){
-	this.params.HAS_OPENED = 1
-	this.params.OPEN_TIME = Date.now()
 
-	clog("WS_OPEN???",{that:this,args:[...arguments]},{on_open_once:this.on_open_once,on_open_cbs:this.params.on_open_cbs})
+	// clog("WS_OPEN???",{that:this,args:[...arguments]},{on_open_once:this.on_open_once,on_open_cbs:this.params.on_open_cbs})
 	// glob_u.ws.sockets.ws1.params.ord.run_cbs("WS_OPEN:",{event,that:this})
 	glob_u.ws.sockets[this.params.socket_name].params.ord.run_cbs("WS_OPEN:",{event,that:this})
 	return
 	return fns
 }
 
-Object.defineProperty(window,'a',{
-    get: function(){
-        console.log('windowProperty is being get...',arguments);
-        glob_u.ws.sockets.ws1.send(`{"a":2.01}`)
-        return 'windowProperty'
-    },
-
-    set: function(val){
-        console.log('windowProperty is being set',arguments);
-    },
-
-    configurable: true,
-});
 
 function connect_ws(o= {}){
 	// clog("connect_ws:",o,jc(o))
 		return
 
 	}
-	var old_url = o.url
-	// location.protocol == "https:" ? clog("HTTPS") : clog("HTTP?")
-	// let vx1
-	// let vx1;location.protocol == "https:" ?  vx1 = "HTTPS" : vx1 = "HTTP?"
-	// clog("VAR DECS",vx1)
-	// o.url = "ws://127.0.0.1:5000/djc_srv/ws/chat/"
-	// o.url = "ws://127.0.0.1:5000/djc_srv/ws/chat"
-	// o.url = "ws://127.0.0.1:5000/echo_c1"
-	// o.url = `ws://${location.hostname}:5000/echo_c1?HELLO__________________________________________________________________________=1`
-	// o.url = `ws://${location.hostname}:5000/echo_c1${location.search}`
-	// o.url = `ws://${location.hostname}:5000/echo_c1?HELLO+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=1`
-	clog("new WebSocket(o.url)",o,o.url,old_url)
-	// var socket = new WebSocket(o.url,["PROTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"])
+
 	var socket = new WebSocket(o.url)
 	socket.on_open_once = []
 	socket.pre_init_msgs = []
 window.glob_u.ws.fns.dispatch = function dispatch(o,obj_x,info){
 	var event = o.event
 	// socket = o.that
-	if (event.data == "::CLOSE::"){
-		clog("comand_CLOSE!!!")
-		o.that.close()
-	}
-	// clog(":event.data:",event.data,[this,o,obj_x,info])
 	var data = JSON.parse(event.data)
 	// clog("WS_dispatch",data,socket.params.ord,data["CLIENT_KEY"])
 	// clog("trc:sto:ws_rec",data.CLIENT_KEY,data.sto_event_type,data)
 
 
 function get_room_name(){
-	// return 
-	var s=location.search
-	// if s[0]=="?"){}
-	s[0]=="?" ?  s = s.slice(1):0
-	var param
-	for (param of s.split("&")){
-
-		let kv = param.split("=")
-		if (kv[0]=="room"){
-			return kv[1]
-		}
-		clog("::",param,kv)
-		// clog("::",param,kv,"")
-	}
-
-	// var 
-	return "room_name"
-	var room_name=location.pathname.match(/\/loc.([^\/]*)\//)
-	if (room_name){
-		room_name = room_name[1]
-	} else {
-	room_name = location.pathname.split("/").pop()
-
-	}
-	return room_name
-
-}
-function get_room_name_old(){
 
 	var room_name=location.pathname.match(/\/loc.([^\/]*)\//)
 	if (room_name){
 				if (glob_u.prom.init_db_resolve.resolved_inited == 2){
 
 				tmsgx4({sto_event_type:"db_sync_response",payload:jc(pf.root),request_from:parsed.from,request_rn_from:parsed.request_rn,"CLIENT_KEY":"ws_sto"})
-				clog("SENDING!@#$%^&*(")
 				}
 
 			break;
 			case "db_sync_response":
 
-			// clog("PROC db_sync_response",parsed,_o)
-
 					if (glob_u.prom.init_db_resolve && parsed.request_rn_from  == glob_u.prom.init_db_resolve.rn){
-			// clog("::PROC db_sync_response::",parsed,_o)
 						glob_u.prom.init_db_resolve({aaa:"dsr",pl:parsed.payload})
-					} else {
-			// clog("NO PROC::PROC db_sync_response::",parsed,_o)
-
 					}
-			clog("::PROC db_sync_response::",glob_u.prom.init_db_resolve.rn==parsed.request_rn_from,glob_u.prom.init_db_resolve.rn,parsed.request_rn_from,parsed,_o)
 				// clog("db_sync_response",parsed)
 			break;
 
 }
 
 function ws_sto_connected(a,b){
-	// clog("")
 
 	glob_u.cb.ws.run_cbs("WS_MSTO_INITED")
 
 
 // TODO:Fix bug caused by a user disconnecting before the connection is properly established
 function connection_info_handler(o,scope,info){
-	// clog("**************************************************************8:",o,scope,info)
 	if (o.data.sto_event_type=="connection_info"){
-	clog("connection_info_handler:",o,scope,info)
+	// clog("connection_info_handler:",o,scope,info)
 		glob_u.data.group_name = o.data.group_name
 		glob_u.data.channel_name = o.data.channel_name
 		clog("jsyncdb connected","room name:",glob_u.data.group_name)
 	} else if (o.data.sto_event_type=="user_disconnected"){
-	clog("user_disconnected_handler:",o,scope,info)
-
 	var last_conn =1
 	var k,v
 	var ws_conn_data = jc(msto.ws_channels[o.data.channel_name])
 	delete msto.ws_channels[o.data.channel_name]
 		for ([k,v] of Object.entries(msto.ws_channels)){
-		clog("ERR!",{channel_name:jc(o.data.channel_name),ws_channels:jc(msto.ws_channels),z:{o,data:o.data}})
-		clog("ERR?",k,v,ws_conn_data)
-		clog("ERR??",jc(msto.ws_channels))
-		clog("ERR???",jc(o.data))
 		if (v.id == ws_conn_data.id){
 			last_conn = 0
 		}
 // console.log("??...")
 
 
-// clog("?????")
+// clog("???")
 // 
 
 
 
+
 // glob_u.fns.get_room_name=get_room_name
 // window.ds_test=ds_test
 // glob_u.fns.ds_test=ds_test
 // window.msto_prx=msto_prx
 
-})()
+})()

js_client/jsync_lib_template.js

 "use strict";
 
+// makestache template info {{{makestache_template_info}}}
+// the following string tells my make scripts its fine to overwtite this the library would have had a template str in the middle of the str
+// BUILT_FILE_{{{"makestache_template"}}}OVERWRITE_ALLOWED
+// {{{out_file_hint>jsync_lib*js}}} ... {{{output_filename}}}
+{{#is_makestache_template}}
+THIS_FILE_IS_A_MAKESTACHE_TEMPLATE
+{{/is_makestache_template}}
+// /* */ 
+
 (function (){
 var isProxy,tlu,msto_z
 var pf,msto_prx
 
 // jsync:dep.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_dep}}}
+{{{jsync_dep*js}}}
 // jsync:ord.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_ord}}}
+{{{jsync_ord*js}}}
 // jsync:ws.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_ws}}}
+{{{jsync_ws*js}}}
 // jsync:sto.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_sto}}}
+{{{jsync_sto*js}}}
 // jsync:init.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_init}}}
+{{{jsync_init*js}}}
 
 // jsync:test.js
 // ------------------------------------------------------------------------------------------------
-{{{jsync_test}}}
+{{{jsync_test*js}}}
+
 
 
 

make.py

 		p("\t\\t\tFILE ERR:::",file_name)
 		p("")
 
-	p("LRN",len(ftxt))
+	# p("LRN",len(ftxt))
 	return r
 
 
 	os.chdir(tglob["OUT_DIR"])
 
 	# dbg_out
-	wfile("mgen1.js",out)
-	wfile("mgen2.js",out2)
+	# wfile("mgen1.js",out)
+	# wfile("mgen2.js",out2)
 	p()
 	if mdict["output_ok"]:
 		p(mdict["outfile"]["_path"])
 
 
 	o = {}
+	p("checking files...")
 	# for en in os.scandir(r"C:\ws\repos\script_utils\makestache"):
 	for en in os.scandir():
 		if isfile(en):
 			o[en] = is_template_file(en)
-			p([en],isfile(en))
+			# p([en],isfile(en))
+			# p(en.name,en.path)
+			if (o[en]["is_template"]):
+				p(":",en.path,"TEMPLATE")
+			else:
+				p(en.path)
+			# p(en.path,"is_template:",bool(o[en]["is_template"]))
 			r'''
 			for en2 in dir(en):
 				if en2[:2]=="__":
 tglob["IN_DIR"] = r"C:\ws\repos\script_utils\makestache\test_src"
 tglob["OUT_DIR"] = r"C:\ws\repos\script_utils\makestache\test_src"
 
+tglob["IN_DIR"]  = os.path.abspath(r"./js_client")
+tglob["OUT_DIR"] = os.path.abspath(r"./js_client")
 
 
-
+orig_dir = os.getcwd()
 
 
 dev_main()
+os.chdir(orig_dir)
+
+# this should exist only on the authors computer (it copies make.py to here so i can run make.py twice and get any file changes)
+if os.path.isfile("udep.bat"):
+	os.system("udep.bat")
+

old.make.py

-import chevron
-
-
-
-files={
-"jsync_dep"  : "jsync_dep.js",
-"jsync_ord"  : "jsync_ord.js",
-"jsync_ws"   : "jsync_ws.js",
-"jsync_sto"  : "jsync_sto.js",
-"jsync_test" : "jsync_test.js",
-"jsync_test2" : "jsync_test2.js",
-"jsync_init" : "jsync_init.js",
-}
-
-def wfile(file_name,out):
-	f = open(file_name,"w")
-	f.write(out)
-	f.close()
-def rfile(file_name):
-	f = open(file_name,"r")
-	ftxt = f.read()
-	f.close()
-	return ftxt
-
-# C:\bspace\repos\jc4\ign4\indx\jsyncdb\jsync_lib_template.js
-def run_now():
-	path = r"C:\bspace\repos\jc4\ign4\indx\jsyncdb" + "\\"
-	files2 = {}
-	for k,v in files.items():
-		ftxt = rfile(path+v)
-		files2[k] = ftxt
-	template = rfile(path+"jsync_lib_template.js")
-	out = chevron.render(template,files2)
-	# wfile("jsync_lib_out.js",out)
-	wfile(path+"jsync_lib.js",out)
-
-# run_now()
-print("This was the old file I used to render the template the new one should keep all (or) most logic in the template")