wuira 0.2.3 → 0.2.5

package/lib/ui/ForEach.lua

@@ -1,5 +1,19 @@
 --[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
 -- Lua Library inline imports
+local function __TS__ObjectRest(target, usedProperties)
+    local result = {}
+    for property in pairs(target) do
+        if not usedProperties[property] then
+            result[property] = target[property]
+        end
+    end
+    return result
+end
+
+local function __TS__ArrayIsArray(value)
+    return type(value) == "table" and (value[1] ~= nil or next(value) == nil)
+end
+
 local function __TS__ArrayMap(self, callbackfn, thisArg)
     local result = {}
     for i = 1, #self do
@@ -7,24 +21,760 @@ local function __TS__ArrayMap(self, callbackfn, thisArg)
     end
     return result
 end
+
+local function __TS__NumberIsFinite(value)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+end
+
+local function __TS__NumberIsInteger(value)
+    return __TS__NumberIsFinite(value) and math.floor(value) == value
+end
+
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+local __TS__Symbol, Symbol
+do
+    local symbolMetatable = {__tostring = function(self)
+        return ("Symbol(" .. (self.description or "")) .. ")"
+    end}
+    function __TS__Symbol(description)
+        return setmetatable({description = description}, symbolMetatable)
+    end
+    Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
+        iterator = __TS__Symbol("Symbol.iterator"),
+        hasInstance = __TS__Symbol("Symbol.hasInstance"),
+        species = __TS__Symbol("Symbol.species"),
+        toStringTag = __TS__Symbol("Symbol.toStringTag")
+    }
+end
+
+local __TS__Iterator
+do
+    local function iteratorGeneratorStep(self)
+        local co = self.____coroutine
+        local status, value = coroutine.resume(co)
+        if not status then
+            error(value, 0)
+        end
+        if coroutine.status(co) == "dead" then
+            return
+        end
+        return true, value
+    end
+    local function iteratorIteratorStep(self)
+        local result = self:next()
+        if result.done then
+            return
+        end
+        return true, result.value
+    end
+    local function iteratorStringStep(self, index)
+        index = index + 1
+        if index > #self then
+            return
+        end
+        return index, string.sub(self, index, index)
+    end
+    function __TS__Iterator(iterable)
+        if type(iterable) == "string" then
+            return iteratorStringStep, iterable, 0
+        elseif iterable.____coroutine ~= nil then
+            return iteratorGeneratorStep, iterable
+        elseif iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            return iteratorIteratorStep, iterator
+        else
+            return ipairs(iterable)
+        end
+    end
+end
+
+local Map
+do
+    Map = __TS__Class()
+    Map.name = "Map"
+    function Map.prototype.____constructor(self, entries)
+        self[Symbol.toStringTag] = "Map"
+        self.items = {}
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if entries == nil then
+            return
+        end
+        local iterable = entries
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                local value = result.value
+                self:set(value[1], value[2])
+            end
+        else
+            local array = entries
+            for ____, kvp in ipairs(array) do
+                self:set(kvp[1], kvp[2])
+            end
+        end
+    end
+    function Map.prototype.clear(self)
+        self.items = {}
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Map.prototype.delete(self, key)
+        local contains = self:has(key)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[key]
+            local previous = self.previousKey[key]
+            if next ~= nil and previous ~= nil then
+                self.nextKey[previous] = next
+                self.previousKey[next] = previous
+            elseif next ~= nil then
+                self.firstKey = next
+                self.previousKey[next] = nil
+            elseif previous ~= nil then
+                self.lastKey = previous
+                self.nextKey[previous] = nil
+            else
+                self.firstKey = nil
+                self.lastKey = nil
+            end
+            self.nextKey[key] = nil
+            self.previousKey[key] = nil
+        end
+        self.items[key] = nil
+        return contains
+    end
+    function Map.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, self.items[key], key, self)
+        end
+    end
+    function Map.prototype.get(self, key)
+        return self.items[key]
+    end
+    function Map.prototype.has(self, key)
+        return self.nextKey[key] ~= nil or self.lastKey == key
+    end
+    function Map.prototype.set(self, key, value)
+        local isNewValue = not self:has(key)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        self.items[key] = value
+        if self.firstKey == nil then
+            self.firstKey = key
+            self.lastKey = key
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = key
+            self.previousKey[key] = self.lastKey
+            self.lastKey = key
+        end
+        return self
+    end
+    Map.prototype[Symbol.iterator] = function(self)
+        return self:entries()
+    end
+    function Map.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = {key, items[key]}}
+            end
+        }
+    end
+    function Map.prototype.keys(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Map.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = items[key]}
+            end
+        }
+    end
+    Map[Symbol.species] = Map
+end
+
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+local Set
+do
+    Set = __TS__Class()
+    Set.name = "Set"
+    function Set.prototype.____constructor(self, values)
+        self[Symbol.toStringTag] = "Set"
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if values == nil then
+            return
+        end
+        local iterable = values
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                self:add(result.value)
+            end
+        else
+            local array = values
+            for ____, value in ipairs(array) do
+                self:add(value)
+            end
+        end
+    end
+    function Set.prototype.add(self, value)
+        local isNewValue = not self:has(value)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        if self.firstKey == nil then
+            self.firstKey = value
+            self.lastKey = value
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = value
+            self.previousKey[value] = self.lastKey
+            self.lastKey = value
+        end
+        return self
+    end
+    function Set.prototype.clear(self)
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Set.prototype.delete(self, value)
+        local contains = self:has(value)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[value]
+            local previous = self.previousKey[value]
+            if next ~= nil and previous ~= nil then
+                self.nextKey[previous] = next
+                self.previousKey[next] = previous
+            elseif next ~= nil then
+                self.firstKey = next
+                self.previousKey[next] = nil
+            elseif previous ~= nil then
+                self.lastKey = previous
+                self.nextKey[previous] = nil
+            else
+                self.firstKey = nil
+                self.lastKey = nil
+            end
+            self.nextKey[value] = nil
+            self.previousKey[value] = nil
+        end
+        return contains
+    end
+    function Set.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, key, key, self)
+        end
+    end
+    function Set.prototype.has(self, value)
+        return self.nextKey[value] ~= nil or self.lastKey == value
+    end
+    Set.prototype[Symbol.iterator] = function(self)
+        return self:values()
+    end
+    function Set.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = {key, key}}
+            end
+        }
+    end
+    function Set.prototype.keys(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.union(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:add(item)
+        end
+        return result
+    end
+    function Set.prototype.intersection(self, other)
+        local result = __TS__New(Set)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.difference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:delete(item)
+        end
+        return result
+    end
+    function Set.prototype.symmetricDifference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            if self:has(item) then
+                result:delete(item)
+            else
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.isSubsetOf(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if not other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isSupersetOf(self, other)
+        for ____, item in __TS__Iterator(other) do
+            if not self:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isDisjointFrom(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    Set[Symbol.species] = Set
+end
+
+local function __TS__ObjectAssign(target, ...)
+    local sources = {...}
+    for i = 1, #sources do
+        local source = sources[i]
+        if type(source) == "table" then
+            for key in pairs(source) do
+                target[key] = source[key]
+            end
+        end
+    end
+    return target
+end
 -- End of Lua Library inline imports
 local ____exports = {}
---- Expands a snapshot into siblings. It creates no native frame or subscription.
-function ____exports.ForEach(self, ____bindingPattern0)
-    local child
-    local items
-    items = ____bindingPattern0.items
-    child = ____bindingPattern0.child
+local ____jsx = require("ui.primitives.jsx")
+local UI = ____jsx.UI
+local ____wuira = require("wuira")
+local wuira = ____wuira.wuira
+--- Arrays expand once; observable lists keep one mounted tree per stable key.
+function ____exports.ForEach(self, props)
+    local ____props_0 = props
+    local items = ____props_0.items
+    local key = ____props_0.key
+    local child = ____props_0.child
+    local onUpdate = ____props_0.onUpdate
+    local onDispose = ____props_0.onDispose
+    local direction = ____props_0.direction
+    if direction == nil then
+        direction = "vertical"
+    end
+    local gap = ____props_0.gap
+    if gap == nil then
+        gap = 0
+    end
+    local lineGap = ____props_0.lineGap
+    if lineGap == nil then
+        lineGap = gap
+    end
+    local wrapAfter = ____props_0.wrapAfter
+    if wrapAfter == nil then
+        wrapAfter = math.huge
+    end
+    local groupBy = ____props_0.groupBy
+    local position = __TS__ObjectRest(____props_0, {
+        items = true,
+        key = true,
+        child = true,
+        onUpdate = true,
+        onDispose = true,
+        direction = true,
+        gap = true,
+        lineGap = true,
+        wrapAfter = true,
+        groupBy = true
+    })
     if type(child) ~= "function" then
         error("ForEach requires a render function as its child")
     end
-    return {
-        kind = "group",
-        props = {},
-        children = __TS__ArrayMap(
-            items,
-            function(____, item, index) return child(nil, item, index) end
+    if __TS__ArrayIsArray(items) then
+        return {
+            kind = "group",
+            props = {},
+            children = __TS__ArrayMap(
+                items,
+                function(____, item, index)
+                    local view = child(nil, item, index)
+                    if key ~= nil then
+                        view.props.key = key(nil, item)
+                    end
+                    return view
+                end
+            )
+        }
+    end
+    if key == nil then
+        error("An observable ForEach requires a stable key")
+    end
+    if wrapAfter ~= math.huge and (not __TS__NumberIsInteger(wrapAfter) or wrapAfter < 1) then
+        error("ForEach wrapAfter must be a positive integer")
+    end
+    if gap < 0 or lineGap < 0 then
+        error("ForEach gaps must be non-negative")
+    end
+    local source = items
+    return UI:createElement(
+        "cell",
+        __TS__ObjectAssign(
+            {},
+            position,
+            {
+                width = position.width or 0,
+                height = position.height or 0,
+                onMount = function(____, host)
+                    local entries = __TS__New(Map)
+                    local stopped = false
+                    local dirty = true
+                    local latest
+                    local lastWidth = -1
+                    local lastHeight = -1
+                    local events = CreateFrame("Frame", nil, UIParent)
+                    local function release(____, entry)
+                        do
+                            local ____try, ____error = pcall(function()
+                                wuira:Unmount(entry.frame)
+                            end)
+                            do
+                                if onDispose ~= nil then
+                                    onDispose(nil, entry.view, entry.item)
+                                end
+                            end
+                            if not ____try then
+                                error(____error, 0)
+                            end
+                        end
+                    end
+                    local function reconcile()
+                        if stopped or not dirty or InCombatLockdown() then
+                            return
+                        end
+                        local values = latest or source.Value
+                        if #values > 1024 then
+                            error("ForEach list exceeds its safety limit")
+                        end
+                        local next = __TS__New(Map)
+                        local created = {}
+                        local ordered = {}
+                        do
+                            local function ____catch(failure)
+                                for ____, entry in ipairs(created) do
+                                    release(nil, entry)
+                                end
+                                error(failure, 0)
+                            end
+                            local ____try, ____hasReturned = pcall(function()
+                                local keys = __TS__New(Set)
+                                local identities = {}
+                                for ____, item in ipairs(values) do
+                                    local identity = key(nil, item)
+                                    if issecretvalue(identity) or type(identity) ~= "string" and type(identity) ~= "number" or type(identity) == "number" and not __TS__NumberIsFinite(identity) or keys:has(identity) then
+                                        error("ForEach requires unique, public keys")
+                                    end
+                                    keys:add(identity)
+                                    identities[#identities + 1] = identity
+                                end
+                                do
+                                    local index = 0
+                                    while index < #values do
+                                        local item = values[index + 1]
+                                        local identity = identities[index + 1]
+                                        local entry = entries:get(identity)
+                                        if entry == nil then
+                                            local view = child(nil, item, index)
+                                            view.props.key = identity
+                                            local frame
+                                            do
+                                                local function ____catch(failure)
+                                                    if onDispose ~= nil then
+                                                        onDispose(nil, view, item)
+                                                    end
+                                                    error(failure, 0)
+                                                end
+                                                local ____try, ____hasReturned = pcall(function()
+                                                    frame = wuira:Mount(view, nil, host)
+                                                    if frame == nil then
+                                                        error("Observable ForEach children must return a Cell")
+                                                    end
+                                                end)
+                                                if not ____try then
+                                                    ____catch(____hasReturned)
+                                                end
+                                            end
+                                            entry = {item = item, view = view, frame = frame}
+                                            created[#created + 1] = entry
+                                        else
+                                            if onUpdate ~= nil then
+                                                onUpdate(nil, entry.view, item, entry.item)
+                                            end
+                                            entry.item = item
+                                        end
+                                        next:set(identity, entry)
+                                        ordered[#ordered + 1] = entry
+                                        index = index + 1
+                                    end
+                                end
+                            end)
+                            if not ____try then
+                                ____catch(____hasReturned)
+                            end
+                        end
+                        for ____, ____value in __TS__Iterator(entries) do
+                            local identity = ____value[1]
+                            local entry = ____value[2]
+                            if not next:has(identity) then
+                                release(nil, entry)
+                            end
+                        end
+                        entries = next
+                        local groups = __TS__New(Map)
+                        do
+                            local index = 0
+                            while index < #ordered do
+                                local entry = ordered[index + 1]
+                                local group = groupBy and groupBy(nil, entry.item) or math.floor(index / wrapAfter)
+                                local values = groups:get(group)
+                                if values == nil then
+                                    values = {}
+                                    groups:set(group, values)
+                                end
+                                values[#values + 1] = entry
+                                index = index + 1
+                            end
+                        end
+                        local cross = 0
+                        local width = 0
+                        local height = 0
+                        for ____, group in __TS__Iterator(groups:values()) do
+                            local cursor = 0
+                            local crossSize = 0
+                            for ____, entry in ipairs(group) do
+                                local w = entry.frame:GetWidth()
+                                local h = entry.frame:GetHeight()
+                                local x = direction == "vertical" and cross or cursor
+                                local y = direction == "vertical" and -cursor or -cross
+                                if x ~= entry.x or y ~= entry.y then
+                                    entry.frame:ClearAllPoints()
+                                    entry.frame:SetPoint(
+                                        "TOPLEFT",
+                                        host,
+                                        "TOPLEFT",
+                                        x,
+                                        y
+                                    )
+                                    entry.x = x
+                                    entry.y = y
+                                end
+                                width = math.max(width, (direction == "vertical" and cross or cursor) + w)
+                                height = math.max(height, (direction == "vertical" and cursor or cross) + h)
+                                cursor = cursor + ((direction == "vertical" and h or w) + gap)
+                                crossSize = math.max(crossSize, direction == "vertical" and w or h)
+                            end
+                            cross = cross + (crossSize + lineGap)
+                        end
+                        if width ~= lastWidth or height ~= lastHeight then
+                            host:SetSize(width, height)
+                            lastWidth = width
+                            lastHeight = height
+                        end
+                        latest = nil
+                        dirty = false
+                    end
+                    local function refresh(____, values)
+                        latest = values
+                        dirty = true
+                        reconcile(nil)
+                    end
+                    events:RegisterEvent("PLAYER_REGEN_ENABLED")
+                    events:SetScript(
+                        "OnEvent",
+                        function()
+                            latest = nil
+                            reconcile(nil)
+                        end
+                    )
+                    local unsubscribe = source:onChange(refresh)
+                    do
+                        local function ____catch(failure)
+                            unsubscribe(nil)
+                            events:UnregisterAllEvents()
+                            events:SetScript("OnEvent", nil)
+                            for ____, entry in __TS__Iterator(entries:values()) do
+                                release(nil, entry)
+                            end
+                            error(failure, 0)
+                        end
+                        local ____try, ____hasReturned = pcall(function()
+                            reconcile(nil)
+                        end)
+                        if not ____try then
+                            ____catch(____hasReturned)
+                        end
+                    end
+                    return function()
+                        stopped = true
+                        unsubscribe(nil)
+                        events:UnregisterAllEvents()
+                        events:SetScript("OnEvent", nil)
+                        events:Hide()
+                        for ____, entry in __TS__Iterator(entries:values()) do
+                            release(nil, entry)
+                        end
+                        entries:clear()
+                    end
+                end
+            }
         )
-    }
+    )
 end
 return ____exports