wuira 0.1.10 → 0.2.1

package/lib/rendering/layout.d.ts

@@ -0,0 +1,16 @@
+import type { CellProps } from "../ui/Cell";
+import type { Element } from "../ui/primitives/jsx";
+import type { Anchor } from "../types/Position";
+import { MeasuredCell } from "../ui/layout/measureLayout";
+import type { RenderedCell } from "./types";
+export declare function prepareLayout(element: Element, parent: wuiraNativeFrame, mountedFrames: ReadonlyMap<CellProps, wuiraNativeFrame>): {
+    measured: MeasuredCell;
+    protectedTree: boolean;
+};
+export declare function createFrames(measured: MeasuredCell, parent: wuiraNativeFrame, mountedFrames: ReadonlyMap<CellProps, wuiraNativeFrame>): {
+    root: wuiraNativeFrame;
+    pending: RenderedCell[];
+    frames: Map<CellProps, wuiraNativeFrame>;
+};
+export declare function resolveAnchors(pending: RenderedCell[], frames: ReadonlyMap<CellProps, wuiraNativeFrame>): Map<wuiraNativeFrame, wuiraNativeFrame>;
+export declare function applyPosition(item: RenderedCell, anchors: ReadonlyMap<wuiraNativeFrame, wuiraNativeFrame>, root: wuiraNativeFrame, rootAnchor?: Anchor): void;

package/lib/rendering/layout.lua

@@ -0,0 +1,594 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+-- Lua Library inline imports
+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 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 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
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____SecureButton = require("platform.SecureButton")
+local validateSecureButton = ____SecureButton.validateSecureButton
+local ____measureLayout = require("ui.layout.measureLayout")
+local measureLayout = ____measureLayout.measureLayout
+local ____widgets = require("rendering.widgets")
+local createWidget = ____widgets.createWidget
+function ____exports.prepareLayout(self, element, parent, mountedFrames)
+    local rootProps = element.props
+    local measured = measureLayout(
+        nil,
+        element,
+        {
+            width = rootProps.width == "inherit" and parent:GetWidth() or nil,
+            height = rootProps.height == "inherit" and parent:GetHeight() or nil
+        }
+    )
+    local ____temp_3 = parent ~= UIParent
+    if ____temp_3 then
+        local ____this_1
+        ____this_1 = parent
+        local ____opt_0 = ____this_1.IsProtected
+        local ____temp_2 = ____opt_0 and ____opt_0(____this_1)
+        if ____temp_2 == nil then
+            ____temp_2 = false
+        end
+        ____temp_3 = ____temp_2
+    end
+    local protectedTree = ____temp_3
+    local seen = __TS__New(Set)
+    local function validate(self, item)
+        if seen:has(item.cell.props) or mountedFrames:has(item.cell.props) then
+            error("A Cell can only be mounted once at a time")
+        end
+        seen:add(item.cell.props)
+        if item.cell.kind == "secureButton" then
+            protectedTree = true
+            validateSecureButton(nil, item.cell.props)
+        end
+        for ____, child in ipairs(item.children) do
+            validate(nil, child)
+        end
+    end
+    validate(nil, measured)
+    if protectedTree and InCombatLockdown() then
+        error("SecureButton: mount protected UI outside combat")
+    end
+    return {measured = measured, protectedTree = protectedTree}
+end
+function ____exports.createFrames(self, measured, parent, mountedFrames)
+    local frames = __TS__New(Map)
+    local pending = {}
+    local function create(self, measured, parent, placement)
+        local ____measured_4 = measured
+        local cell = ____measured_4.cell
+        local width = ____measured_4.width
+        local height = ____measured_4.height
+        if frames:has(cell.props) or mountedFrames:has(cell.props) then
+            error("A Cell can only be mounted once at a time")
+        end
+        local frame = createWidget(nil, cell, parent)
+        frames:set(cell.props, frame)
+        pending[#pending + 1] = {
+            cell = cell,
+            width = width,
+            height = height,
+            margin = measured.margin,
+            frame = frame,
+            parent = parent,
+            placement = placement
+        }
+        frame:SetSize(width, height)
+        do
+            local index = 0
+            while index < #measured.children do
+                local ____create_8 = create
+                local ____measured_children_index_7 = measured.children[index + 1]
+                local ____opt_5 = measured.placements
+                ____create_8(nil, ____measured_children_index_7, frame, ____opt_5 and ____opt_5[index + 1])
+                index = index + 1
+            end
+        end
+        return frame
+    end
+    local root = create(nil, measured, parent)
+    return {root = root, pending = pending, frames = frames}
+end
+function ____exports.resolveAnchors(self, pending, frames)
+    local anchors = __TS__New(Map)
+    for ____, item in ipairs(pending) do
+        local position = item.cell.props
+        if item.placement ~= nil then
+            anchors:set(item.frame, item.parent)
+        elseif position.mode == "absolute" then
+            anchors:set(item.frame, UIParent)
+        else
+            local target = position.relativeTo == nil and item.parent or frames:get(position.relativeTo.props)
+            if target == nil then
+                error("relativeTo must reference a Cell in the same mounted tree")
+            end
+            if target == item.frame then
+                error("A Cell cannot anchor to itself")
+            end
+            anchors:set(item.frame, target)
+        end
+    end
+    for ____, item in ipairs(pending) do
+        local target = anchors:get(item.frame)
+        while target ~= nil do
+            if target == item.frame then
+                error("Cell positioning contains an anchor cycle")
+            end
+            target = anchors:get(target)
+        end
+    end
+    return anchors
+end
+function ____exports.applyPosition(self, item, anchors, root, rootAnchor)
+    local position = item.cell.props
+    local target = anchors:get(item.frame)
+    local ____opt_9 = item.placement
+    local x = ____opt_9 and ____opt_9.x or (position.mode == "absolute" and position.x or position.offset.x)
+    local ____opt_11 = item.placement
+    local y = ____opt_11 and ____opt_11.y or (position.mode == "absolute" and position.y or position.offset.y)
+    local ____temp_13
+    if item.frame == root then
+        ____temp_13 = rootAnchor
+    else
+        ____temp_13 = nil
+    end
+    local overrideAnchor = ____temp_13
+    local anchor = overrideAnchor or (item.placement ~= nil and "TOPLEFT" or (position.anchor or "TOPLEFT"))
+    local relativeAnchor = overrideAnchor or (item.placement ~= nil and "TOPLEFT" or (position.relativeAnchor or anchor))
+    item.frame:SetPoint(
+        anchor,
+        target,
+        relativeAnchor,
+        x + item.margin.left,
+        -(y + item.margin.top)
+    )
+end
+return ____exports

package/lib/rendering/progress.d.ts

@@ -0,0 +1,2 @@
+import type { MountedTree, RenderedCell } from "./types";
+export declare function renderProgress(item: RenderedCell, tree: MountedTree, onActiveChange: (active: boolean) => void): void;