wuira 0.1.4 → 0.1.6

package/lib/platform/BlizzardUI.lua

@@ -0,0 +1,689 @@
+--[[ 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 __TS__Unpack = table.unpack or unpack
+
+local function __TS__CountVarargs(...)
+    return select("#", ...)
+end
+
+local function __TS__SparseArrayNew(...)
+    local sparseArray = {...}
+    sparseArray.sparseLength = __TS__CountVarargs(...)
+    return sparseArray
+end
+
+local function __TS__SparseArrayPush(sparseArray, ...)
+    local args = {...}
+    local argsLen = __TS__CountVarargs(...)
+    local listLen = sparseArray.sparseLength
+    for i = 1, argsLen do
+        sparseArray[listLen + i] = args[i]
+    end
+    sparseArray.sparseLength = listLen + argsLen
+end
+
+local function __TS__SparseArraySpread(sparseArray)
+    local _unpack = unpack or table.unpack
+    return _unpack(sparseArray, 1, sparseArray.sparseLength)
+end
+
+local function __TS__ArrayPush(self, ...)
+    local items = {...}
+    local len = #self
+    for i = 1, #items do
+        len = len + 1
+        self[len] = items[i]
+    end
+    return len
+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 ____MicroMenu = require("platform.MicroMenu")
+local skinMicroMenu = ____MicroMenu.skinMicroMenu
+--- Opt-in stock UI visibility. Native buttons, bindings and event handlers remain intact.
+____exports.BlizzardUI = __TS__Class()
+local BlizzardUI = ____exports.BlizzardUI
+BlizzardUI.name = "BlizzardUI"
+function BlizzardUI.prototype.____constructor(self)
+end
+function BlizzardUI.SkinMicroMenu(self, options)
+    if options == nil then
+        options = {}
+    end
+    return skinMicroMenu(nil, options)
+end
+function BlizzardUI.DisableActionBars(self)
+    local unhide = self:Hide({actionBars = true})
+    local listener = CreateFrame("Frame", nil, UIParent)
+    local roots = {
+        "MainActionBar",
+        "MainMenuBar",
+        "MultiBarBottomLeft",
+        "MultiBarBottomRight",
+        "MultiBarRight",
+        "MultiBarLeft",
+        "MultiBar5",
+        "MultiBar6",
+        "MultiBar7",
+        "StanceBar",
+        "PetActionBar"
+    }
+    local managers = {
+        "ActionBarController",
+        "ActionBarButtonEventsFrame",
+        "ActionBarActionEventsFrame",
+        "ActionBarButtonUpdateFrame",
+        "ActionBarButtonRangeCheckFrame",
+        "ActionBarButtonUsableWatcherFrame"
+    }
+    local function apply()
+        if InCombatLockdown() then
+            return
+        end
+        local seen = __TS__New(Set)
+        local quiet
+        quiet = function(____, frame)
+            if frame == nil or frame.UnregisterAllEvents == nil or seen:has(frame) then
+                return
+            end
+            seen:add(frame)
+            frame:UnregisterAllEvents()
+            frame:SetScript("OnEvent", nil)
+            frame:SetScript("OnUpdate", nil)
+            if frame.GetChildren ~= nil then
+                local children = {frame:GetChildren()}
+                for ____, child in ipairs(children) do
+                    quiet(nil, child)
+                end
+            end
+        end
+        local ____array_0 = __TS__SparseArrayNew(__TS__Unpack(roots))
+        __TS__SparseArrayPush(
+            ____array_0,
+            __TS__Unpack(managers)
+        )
+        for ____, name in ipairs({__TS__SparseArraySpread(____array_0)}) do
+            quiet(nil, _G[name])
+        end
+        for ____, prefix in ipairs({
+            "ActionButton",
+            "MultiBarBottomLeftButton",
+            "MultiBarBottomRightButton",
+            "MultiBarRightButton",
+            "MultiBarLeftButton",
+            "MultiBar5Button",
+            "MultiBar6Button",
+            "MultiBar7Button"
+        }) do
+            do
+                local index = 1
+                while index <= 12 do
+                    local button = _G[prefix .. tostring(index)]
+                    if button ~= nil then
+                        local ____opt_1 = C_ActionBar and C_ActionBar.UnregisterActionUIButton
+                        if ____opt_1 ~= nil then
+                            ____opt_1(button)
+                        end
+                    end
+                    index = index + 1
+                end
+            end
+        end
+    end
+    listener:RegisterEvent("ADDON_LOADED")
+    listener:RegisterEvent("PLAYER_ENTERING_WORLD")
+    listener:RegisterEvent("PLAYER_REGEN_ENABLED")
+    listener:SetScript("OnEvent", apply)
+    apply(nil)
+    return function()
+        listener:UnregisterAllEvents()
+        listener:SetScript("OnEvent", nil)
+        unhide(nil)
+    end
+end
+function BlizzardUI.Hide(self, options)
+    local names = {}
+    if options.actionBars then
+        __TS__ArrayPush(
+            names,
+            "MainActionBar",
+            "MainMenuBar",
+            "MultiBarBottomLeft",
+            "MultiBarBottomRight",
+            "MultiBarRight",
+            "MultiBarLeft",
+            "MultiBar5",
+            "MultiBar6",
+            "MultiBar7",
+            "StanceBar",
+            "PetActionBar"
+        )
+    end
+    if options.player then
+        names[#names + 1] = "PlayerFrame"
+    end
+    if options.target then
+        names[#names + 1] = "TargetFrame"
+    end
+    if options.focus then
+        names[#names + 1] = "FocusFrame"
+    end
+    local hidden = CreateFrame("Frame", nil, UIParent)
+    hidden:SetAllPoints(UIParent)
+    hidden:Hide()
+    local listener = CreateFrame("Frame", nil, UIParent)
+    local parents = __TS__New(Map)
+    local enabled = true
+    local function apply()
+        if InCombatLockdown() then
+            return
+        end
+        if not enabled then
+            for ____, ____value in __TS__Iterator(parents) do
+                local frame = ____value[1]
+                local parent = ____value[2]
+                if frame:GetParent() == hidden then
+                    frame:SetParent(parent)
+                end
+            end
+            parents:clear()
+            listener:UnregisterAllEvents()
+            listener:SetScript("OnEvent", nil)
+            listener:Hide()
+            return
+        end
+        for ____, name in ipairs(names) do
+            do
+                local __continue31
+                repeat
+                    local frame = _G[name]
+                    if frame == nil then
+                        __continue31 = true
+                        break
+                    end
+                    if not parents:has(frame) then
+                        parents:set(
+                            frame,
+                            frame:GetParent()
+                        )
+                        frame:HookScript(
+                            "OnShow",
+                            function()
+                                if enabled and not InCombatLockdown() and frame:GetParent() ~= hidden then
+                                    frame:SetParent(hidden)
+                                end
+                            end
+                        )
+                    end
+                    if frame:GetParent() ~= hidden then
+                        frame:SetParent(hidden)
+                    end
+                    __continue31 = true
+                until true
+                if not __continue31 then
+                    break
+                end
+            end
+        end
+    end
+    listener:RegisterEvent("PLAYER_REGEN_ENABLED")
+    listener:RegisterEvent("PLAYER_ENTERING_WORLD")
+    listener:RegisterEvent("ADDON_LOADED")
+    listener:SetScript("OnEvent", apply)
+    apply(nil)
+    return function()
+        enabled = false
+        apply(nil)
+    end
+end
+return ____exports

package/lib/platform/MicroMenu.d.ts

@@ -0,0 +1,15 @@
+import type { Color } from "../types/Color";
+export interface MicroMenuSkinOptions {
+    background?: Color;
+    border?: Color;
+    buttonBackground?: Color;
+    icon?: Color;
+    accent?: Color;
+    disabledIcon?: Color;
+    padding?: number;
+    panel?: boolean;
+}
+/** Style Forever's existing micro buttons without replacing their scripts or layout.
+ * Disposing stops maintenance; reload restores the native textures.
+ */
+export declare function skinMicroMenu(options?: MicroMenuSkinOptions): () => void;