init.lua

K =
 (function()
 local local_k = {}
 local callbacks = {}

 local k_client_id = bitstring.hexstream(Crypto.Digest("sha256", Crypto.GetRandomBytes(32)))

 local startup_time = Timer.Now()

 local peers = {}

 local function best_peer()
 -- Remove peers from peers table that are no longer connected
 -- Peers is a table of last-seen timestamps, indexed by peer ID
 for peer_id, last_seen in pairs(peers) do
 if Timer.Now() - last_seen > 15 then
 peers[peer_id] = nil
 end
 end

 -- Otherwise, return the peer with the most recent timestamp
 local best_peer_id = k_client_id
 for peer_id in pairs(peers) do
 if peer_id > best_peer_id then
 best_peer_id = peer_id
 end
 end
 return best_peer_id
 end

 local function publish(diff, type)
 Notifications.Publish("com.locimation.K", {k = diff, s = k_client_id, t = type})
 end

 _G._locimation_k_timer = Timer.New()
 local source_data = nil

 local function source_clear(data, t)
 if not t then
 t = source_data
 end
 for k, v in pairs(data) do
 if type(v) == "table" and type(t[k]) == "table" then
 t[k] = source_clear(v, t[k])
 else
 t[k] = nil
 end
 end
 end

 _G._locimation_k_timer.EventHandler = function()
 if source_data then
 publish(source_data, "refresh")
 end
 if Timer.Now() - startup_time > 15 and best_peer() == k_client_id then
 Timer.CallAfter(
 function()
 publish(local_k, "broadcast")
 end,
 math.random()
 )
 end
 end

 _G._locimation_k_timer:Start(10)

 local function extract(t, k)
 if not k or k == "" then
 return t
 end
 local value = t
 for part in k:gmatch("([^.]+)") do
 value = value[part]
 if value == nil then
 return nil
 end
 end
 return value
 end

 local function deepcopy(t)
 if type(t) ~= "table" then
 return t
 end
 local new_t = {}
 for k, v in pairs(t) do
 if type(v) == "table" then
 new_t[k] = deepcopy(v)
 else
 new_t[k] = v
 end
 end
 return new_t
 end

 local function deepcompare(t1, t2)
 if type(t1) ~= "table" or type(t2) ~= "table" then
 return t1 == t2
 end
 for k, v in pairs(t1) do
 if not deepcompare(v, t2[k]) then
 return false
 end
 end
 for k, v in pairs(t2) do
 if not deepcompare(v, t1[k]) then
 return false
 end
 end
 return true
 end

 local function push_k(new_k)
 if type(new_k) ~= "table" then
 error("Invalid argument to push_k(): expected table")
 end
 local changes = {}
 for key in pairs(callbacks) do
 local old_value = extract(local_k, key)
 local new_value = extract(new_k, key)
 if not deepcompare(old_value, new_value) then
 changes[key] = deepcopy(new_value)
 end
 end
 local_k = new_k
 for key, new_value in pairs(changes) do
 for _, fn in ipairs(callbacks[key]) do
 fn(new_value)
 end
 end
 end

 local function merge(t1, t2)
 if type(t1) ~= "table" or type(t2) ~= "table" then
 return t2
 end
 local new_t = deepcopy(t1)
 for k in pairs(t2) do
 if type(t1[k]) == "table" and type(t2[k]) == "table" then
 new_t[k] = merge(t1[k], t2[k])
 else
 new_t[k] = t2[k]
 end
 end
 return new_t
 end

 local function init()
 Notifications.Subscribe(
 "com.locimation.K",
 function(_, message)
 Timer.CallAfter(
 function()
 if message.s == k_client_id then
 return
 end
 peers[message.s] = Timer.Now()
 if message.t ~= "broadcast" and source_data then
 source_clear(message.k)
 end
 local new_k = merge(local_k, message.k)
 if message.t == "broadcast" and source_data then
 new_k = merge(new_k, source_data)
 end
 push_k(new_k)
 end,
 0
 )
 end
 )
 end

 local function now(diff)
 source_data = merge(source_data or {}, diff)
 push_k(merge(local_k, diff))
 publish(diff, "new")
 end

 local function on(key, fn)
 if type(key) ~= "string" or type(fn) ~= "function" then
 error("Invalid arguments to on(): expected (string, function)")
 end
 if not callbacks[key] then
 callbacks[key] = {}
 end
 for _, existing_fn in ipairs(callbacks[key]) do -- prevent duplicate callbacks
 if existing_fn == fn then
 return
 end
 end
 table.insert(callbacks[key], fn)
 end

 local function off(key, fn)
 if not key then
 callbacks = {}
 return
 end
 if not callbacks[key] then
 return
 end
 local callbacks_filtered = {}
 if fn then
 for _, f in pairs(callbacks[key]) do
 if f ~= fn then
 table.insert(callbacks_filtered, f)
 end
 end
 end
 callbacks[key] = callbacks_filtered
 end

 local function set(str_key, value)
 local parts = {}
 for part in str_key:gmatch("([^.]+)") do
 table.insert(parts, 1, part)
 end
 for _, part in ipairs(parts) do
 value = {[part] = value}
 end
 now(value)
 end

 local function link(key, control, typ, options)
 if type(key) ~= "string" or type(control) ~= "userdata" or type(typ) ~= "string" then
 error("Invalid arguments to link(): expected (string, control, string)")
 end

 local function set_control_value()
 set(key, control[typ])
 end

 local options = options or {}
 control.EventHandler = set_control_value
 on(
 key,
 function(value)
 control[typ] = value
 end
 )
 if not options.no_init then
 Timer.CallAfter(set_control_value, math.random() + 0.3)
 end
 end

 local function get(key)
 return extract(local_k, key)
 end

 return {
 init = init,
 now = now,
 set = set,
 on = on,
 off = off,
 link = link,
 get = get
 }
end)()