jitsi_app_c0/mdev/dev_sto.native.js

var NS = {
	// set_msg:"update_query"
	UPDATE_QUERY:"set_msg",
	// UPDATE_QUERY:"update_query",
	JOIN_DB:"connect_jdb",
	// JOIN_DB:"update_query",
}
function pfnf(o){
	return  function(resolve, reject){
		o.resolve=resolve
		o.reject=reject
		// clog(arguments)
	}
}
var isProxy = Symbol("isProxy")

var tlu = {
	object:"",
	string:true,
	number:true,
	undefined:true,
	boolean:true,
}
function arr_match(m,o){
	var k,v
	var r = 0
	for ([k,v] of Object.entries(m || {})){
		if (o[k] != v.valueOf()){
			r += 1
			return !r
		}

	// for ([k,v] in m){
		// case
		// dlog(k,v)
	}
	return !r
}
function type_info(o){
	try {

	var t
	var flags = {
		leaf:false,
		deep_not_prx:false,
		prx:false,
		isObj:false,
		isArr:false,
		els:false,
	}
	t = typeof(o)
	flags.t=t
	// window?.glob_mx?.flags?.type_info_dbg ? clog("type_info") : 0
	if (!(o === null)){
		flags.isArr = Array.isArray(o)
		flags.isObj = Object.prototype == o.__proto__
	}

	if (tlu[t] === true || o === null){
		flags.leaf = true
	} else if (t == "object" && o.__prx){
		flags.prx = true
	} else if (t == "object" && (flags.isArr || flags.isObj)){
		flags.prx = false
		flags.deep_not_prx = true
	} else {
		clog("ELSE")
		flags.els = true
	}

	return flags

	// !window?.glob_mx?.flags?.type_info_dbg ? clog("type_info") : 0
	} catch (err){
		clog("type_info err:",err,{flags,o})
	}
	// clog(t,flags)
}
function deep_prop_v0(o,p){
	try {
	var arr = jc(p)
	var ret = o

	while (arr.length){
		// clog("deep_prop",arr,ret)
		ret = ret[arr.shift()]
	}
	// clog("deep_prop ret",ret)
	return ret
	} catch(err){console.error("DEEP_PROP ERR:",err)}
}



















class Proxy_Factory {

	constructor(o,n="dflt",base_n="dflt",full_n="dflt-dflt",socket_name=""){
		this.db = o
		this.n = n
		this.socket_name = socket_name
		this.base_n = base_n
		this.full_n = full_n

		this.hidden_props = ["add_proxy","_set","walker","walker_start","prxy","_sett","_sett2"]
		this._pub_cb =[]
		this.__prx = true
		this.SymPrx = Symbol("SymPrx")
		clog("mx Proxy_Factory")


		// clog("pfx",{o,n,that:this})
	}


	constructor_x(){
		// o,n="dflt",base_n="dflt",full_n="dflt-dflt",socket_name=""
		// this.constructor_m(...arguments)
		clog("Proxy_Factory constructor")
		Proxy_Factory.prototype.constructor_m.call(this,...arguments)
	}
			mx1(){
		clog(("mx1: Proxy_Factory"))
	}


	init(o){
		// dlog("BP",this,this.baseProp,this.__proto__.baseProp,window.baseProp)
		// clog("pfx init",{o,that:this})
		this.root = o
	}
	sync(o){
		this.root = jc(o.root)
		o._pub_cb.push(this._set_recv.bind(this))
	}
	get prxy(){
		return this
	}

	_set(o,k,v,prx,a0){
		this.obj[k]=prx
	}

	_sett(o,k,v,prx,a0){
		dlog("_SETT",this,arguments)
	}
	_sett2(o,k,v,prx,a0){
		dlog("_SETT2",this,arguments)
	}

	set_pub(obj, prop, val,receiver){
		// dlog("qia_pub",obj, prop, val,receiver)
		// dlog("qia_pub2",this.n,obj.__path_arr, prop, jx(val))
		this._set_pub(obj.__path_arr, prop, jx(val))

	}
	// dev_glob.fns.tmp_send

	_connect_db(){
			/*
		dev_glob.fns.tmp_send({
				"key":"connect_jdb",
				// ,
				init_obj:this.db,
				"payload":{},
				db_id:this.db_conn.db_id,
		},this.socket_name)
		//	*/
			this._wssto_send({
				// "key":"connect_jdb",
				"key":NS.JOIN_DB,
				// ,
				tx:["abc",,2],
				init_obj:this.db,
				"payload":{},
			})
	}


	get db_conn(){
		return {db_id:{n:this.n,base_n:this.base_n,full_n:this.full_n},socket_name:this.socket_name}
	}
	// _req_sync(){}
	_wssto_send(o){
		clog("wssto: m0")
		if (!o.wssto_key){
			o.wssto_key = o.key
			o.key = "wssto"
		}
		// o.key = "_wssto_" + o.key
		this.send(o)
	}
	send(o){
		// dev_glob.fns.tmp_send({
		glob_vhook.fns.tmp_send({
				db_id:this.db_conn.db_id,
				...o,
				},this.socket_name)
	}
	send_raw(){
		clog("DBQ")
	}

	_set_pub(path,key,val){
		var k,v

		clog("dev_sto","_set_pub")
					 /*
			tmsgx({
				"type":"set_msg",
				"payload":{path,key,val},
			},"code")
			//		*/
			//
			this._wssto_send({
				// "type":"set_msg",
				"type":NS.UPDATE_QUERY,
				"key":NS.UPDATE_QUERY,
				"payload":{path,key,val},
			})
			/*
			dev_glob.fns.tmp_send({

			// tmsgx3({
			// })
				"type":"set_msg",
				"key":"set_msg",
				db_id:this.db_conn.db_id,
				// "payload":{path,key,val,db_id:{n:this.n,base_n:this.base_n}},},this.socket_name
				"payload":{path,key,val},},this.socket_name
				// window.tmsgx_to || {}
			// {to:"nl4qbyiz61z-mce1@specplot.com/FlUkwrLs"},
			// {to:"maf@conference.i.specplot.com/0695c1e4"},
			// {},
			)
			*/
		for (v of this._pub_cb){
			v(path,key,val)

		}
	}

	_set_recv(path,prop,val){
		// return
		var p = path
		var nprop = deep_prop_v0(this.root,p)
		clog("_set_recv:",nprop)
		var dpth = nprop.__dpth
		if (tlu[typeof(val)]){
		nprop._set(nprop,prop,val,val)
		} else {
		nprop._set(nprop,prop,val,new Proxy(val,this))
		nprop[prop].add_proxy(nprop,prop,val,dpth+1)
		}
		// var tf = {}
		// this.walker(nprop[prop],tf,dpth+2)
		this.walker(nprop[prop],{},dpth+2)
	}

	set(obj, prop, val,receiver){
		// dlog("prx_db set ",this,obj, prop, val,receiver,val.__prx)
		// clog("prx_db set ",{that:this,obj, prop, val,receiver},val.__prx)
		// clog("prx_db set ",obj.__path_arr)
		if (obj[prop] === val){
			return Reflect.set(...arguments)
		}

		this.set_pub(obj, prop, val,receiver)
		this.event_proc("set")

		if ("__prx" == prop){
			this.__prx=val
			return this.__prx
		}

		if (typeof(val) === "object" && val != null && !(val.__prx)){
			var ret = Reflect.set(...arguments)
			this.set_obj(obj, prop, val,receiver)
			return ret
		}

		return Reflect.set(...arguments)
	}
	get(obj, prop,receiver){
		// dlog("prx_db get ...",prop==isProxy,this,obj, prop,receiver)
		if (this.hidden_props.includes(prop)){
			switch (prop){
				case "add_proxy":
				return this.add_proxy.bind(this)
			break;
				case "prxy":
				return this
				case "_set":
				// dlog("_SET")
				// return this._set.bind({this})
				return this._set.bind({that:this,obj, prop,receiver})
				case "_sett":
				return this._sett.bind({that:this,obj, prop,receiver})
				case "_sett2":
				return this._sett2.bind({that:this})
				case "walker_start":
				return this.walker_start
				case "walker":
				return this.walker
			break;
			}
		}

		if (isProxy == prop){ return true }
		if ("__prx" == prop){ return this.__prx }

		return Reflect.get(...arguments)
	}
	add_proxy(o,k,v,dpth){
		// clog("~add_proxy~",o,k,v,dpth)
		// clog("~add_proxy~",o.__prx,o,k,v,dpth,xpath)
		var xpath = o.__path
		var apath = o.__path_arr
		this.event_proc("add_proxy")
		if (!apath){
			apath=[]
		}

		if (!xpath){
			xpath="ROOT!"
		}

		Object.defineProperty(v,"__path_arr",Object.assign({value:apath.concat(k),},this.baseProp))
		Object.defineProperty(v,"__path",Object.assign({value:xpath+":"+k,},this.baseProp))
		Object.defineProperty(v,"__dpth",Object.assign({value:dpth,},this.baseProp))
		// Object.defineProperty(v,"__dbg",Object.assign({value:{},},this.baseProp))

	}
	set_obj(obj, prop, val,receiver){
		var dpth = obj.__dpth
		var tf = {}
		this.walker(receiver,tf,dpth)
	}

	walker(o,tfo,dpth=0){
		// dlog("qia WALK",this)
		if (dpth > 7){
			console.error("MAX DEPTH")
			return
		}
		var k,v
		var tf
			for ([k,v] of Object.entries(o)){
				tf = type_info(v)
				if (tf.deep_not_prx){
					o._set(o,k,v,new Proxy(v,this.prxy))
					o[k].add_proxy(o,k,v,dpth)
				this.walker(o[k],tf,dpth+1)
				}
			}
	}
	walker_start(o,dpth){
		var tf = type_info(o)
		o.add_proxy({},[],o,-1)
		this.walker(o,tf,0)
	}
	event_proc(e){}
}

var permissions_def = {
	participants:{
		m:["participants"],
		fn(set_scope,match){


			// clog("FN....",match.fp,match.fp[1] == window.glob_mx.local_id)
			return 
			/*
			if (match.fp[1] != window.glob_mx.local_id)
				throw "permission err"
			return
			*/
		},
	}
}


	class Proxy_Permissions extends Proxy_Factory {
		// constructor_m(a,a1){
		constructor(a,a1){
			clog("mx Proxy_Permissions")
			super(...arguments)
		}
	constructor_x(){
		// o,n="dflt",base_n="dflt",full_n="dflt-dflt",socket_name=""
			super.constructor_x(...arguments)
		this.constructor_m(...arguments)
		// Proxy_Permissions.prototype.constructor_m.call(this,...arguments)
		// this.prototype.constructor_m.call(this,...arguments)
	}
		mx1(){
		clog(("mx1: Proxy_Permissions"))
	}


		set(obj, prop, val,receiver){
			// clog("PRX_PERM",obj.__path_arr,prop)
			var k,v
			var r
			var matched
			var fp = obj.__path_arr.concat(prop)
			for ([k,v] of Object.entries(permissions_def)){
				matched = arr_match(v.m,fp)
				if (matched){
					r = v.fn({that:this,obj, prop, val,receiver},{fp,k,v}) || {}
				}
				// if (r.return)
			}
			// case
			// if (obj.__path_arr && obj.__path_arr.length){}
			return super.set(obj, prop, val,receiver)
		}
		_set(){
			// clog("Proxy_Permissions _set")
			super._set(...arguments)
		}
	}



function splice_out(arr,elm){
	let i = arr.indexOf(elm)
	// var r = "" 
	if (i != -1){
		return arr.splice(i,1)
	}
	// return

}
function gen_sort_attr(attr){
	return function gsort(a0,a1){

	// clog("z",a0,a1)
	if (a0[attr] > a1[attr]){
	return 1

	} else if (a0[attr] < a1[attr]){
	return -1

	} else {
	return 0

	}
	}
}
function find_attr(elm,indx,arr){
		// this.attr
		// this.val
		// clog("F",{that:this,elm,indx,arr})
		// if ( elm[this.attr] == this.val){
		if (elm && elm[this.attr] == this.val){
			return 1
		}
	
}




var dflt_opts = {
	sort_fn:gen_sort_attr("override_level"),
	log_level:0,
	// ns:"",
}
class BoundObj{
	constructor(){
		this.init()
	}

    init(){
        let k,v,i,j
        for ([k,v] of Object.entries(Object.getOwnPropertyDescriptors(this.__proto__))){
            if (k.endsWith("_ub") && typeof(v.value) == "function"){
                // clog("UB",k,k.slice(1,-3))
                j = v.value.bind(this)
                j.meta_str = "bound_fn"
                this[k.slice(1,-3)] = j
            }
        }
        

    }
    /*
	mx2_ub(){
		clog("Mx2")
	}
    */


}

// class reg_cb_ord{
class reg_cb_ord extends BoundObj{
	// con
	constructor(opts){
		super()
		this.opts = Object.assign({},dflt_opts,opts)
		this.r = Object.assign(this,dflt_opts,opts)
		// this.sort_fn = this.opts

		this.cb_sto = {}
		this._orig_opts = opts
		clog("v2 ",this)
	}
	_reg_cb_ub(cb,key_name,cb_name,override_level = 100,push=1){

		if (typeof(cb) != "function"){
			console.error("callback is not a function. setting push=r","\ncb:",cb)
			push = "r"
			// console.error("callback:",cb," is not a function")
		}
		// var this.cb_sto = {}
		var cb_sort = nop
	
		if (!this.cb_sto[key_name]){
			this.cb_sto[key_name] = []
		}
		// this.cb_sto[key_name].find(find_html_cb,{fn_key:cb_name})
		// splice_out_ti(this.cb_sto[key_name],this.cb_sto[key_name].find(find_html_cb,{fn_key:cb_name}))
		// var cbo0= this.cb_sto[key_name].find(glob_td.fn.find_html_cb,{fn_key:cb_name})
		// var cbo0= this.cb_sto[key_name].find(find_attr,{fn_key:cb_name})
		var cbo0= this.cb_sto[key_name].find(find_attr,{attr:"fn_key",val:cb_name})
		// clog(cbo0)
		splice_out(this.cb_sto[key_name],cbo0)
		// tn2t.arr.
	
		// splice_out_cb
		let cb_obj = {
			cb,
			hkey:key_name,
			fn_key:cb_name,
			override_level,
		}
		if (push=="r"){
	
		} else if (push){
			this.cb_sto[key_name].push(cb_obj)
		} else {
			this.cb_sto[key_name].unshift(cb_obj)
		}
		this.cb_sto[key_name].sort(this.sort_fn)


	}
	_run_cbs_ub(key,arg_obj){
		// if (!key in this.cb_sto){return}
		// clog("_run_cbs_ub:",key)
	
		var k,v
		var o = {
			// html_key:key,cbs:glob_mx.html_cb[key],
		}
	
			// dlog("RUN_HOOK_CB??",key,glob_mx.hook_cb[key])
		try {
	
			this.opts.log_level  ? clog("run_cbs",arg_obj,o,{that:this,hkey:key,cbs:this.cb_sto[key]}) : 0
	
	
		for ([k,v] of Object.entries(this.cb_sto[key]|| {}) ) {
			// dlog("RUN_HOOK_CB:",k)
			// clog("run_html_cbs:",k,v)

			this.opts.log_level > 1 ? clog("run_cbs_e",arg_obj,o,{that:this,hkey:key,cbs:this.cb_sto[key],k,v}) : 0

			v.cb(
				arg_obj,o,{that:this,hkey:key,cbs:this.cb_sto[key],k,v}
				)
			
			// v(o)
		}
		return {
			arg_obj,o,ord_that:{that:this,hkey:key,cbs:this.cb_sto[key],k,v}
		}
		} catch(err){
			console.error("ti_v_cb err:",err)
			console.log("ti_v_cb err:",err)
		}

	}
/*	fn1(){
		clog("fn1",{that:this,args:[...arguments]})
	}*/
}












window.tmp_dev_sto = {
	Proxy_Factory,Proxy_Permissions,reg_cb_ord,BoundObj
}
// Proxy_Factory