wuira 0.1.5 → 0.1.7

package/lib/platform/AddonSettings.d.ts

@@ -0,0 +1,9 @@
+import type { Cell } from "../ui/Cell";
+/** Registers a JSX settings view in the client's native addon settings list. */
+export declare class AddonSettings {
+    readonly Frame: wuiraNativeFrame;
+    private readonly category;
+    constructor(name: string, view: Cell | (() => Cell | void));
+    Open(): void;
+    Close(): void;
+}

package/lib/platform/AddonSettings.lua

@@ -0,0 +1,36 @@
+--[[ 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
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____wuira = require("wuira")
+local wuira = ____wuira.wuira
+--- Registers a JSX settings view in the client's native addon settings list.
+____exports.AddonSettings = __TS__Class()
+local AddonSettings = ____exports.AddonSettings
+AddonSettings.name = "AddonSettings"
+function AddonSettings.prototype.____constructor(self, name, view)
+    if (Settings and Settings.RegisterCanvasLayoutCategory) == nil then
+        error("AddonSettings: native settings API is unavailable")
+    end
+    self.Frame = CreateFrame("Frame", nil, UIParent)
+    self.Frame:Hide()
+    wuira:Mount(view, nil, self.Frame)
+    self.category = Settings.RegisterCanvasLayoutCategory(self.Frame, name)
+    Settings.RegisterAddOnCategory(self.category)
+end
+function AddonSettings.prototype.Open(self)
+    Settings.OpenToCategory(self.category:GetID())
+end
+function AddonSettings.prototype.Close(self)
+    local ____opt_2 = _G.SettingsPanel
+    if ____opt_2 ~= nil then
+        ____opt_2:Hide()
+    end
+end
+return ____exports

package/lib/platform/BlizzardUI.d.ts

@@ -1,3 +1,4 @@
+import type { MicroMenuSkinOptions } from "./MicroMenu";
 export interface BlizzardUIOptions {
     actionBars?: boolean;
     player?: boolean;
@@ -7,6 +8,10 @@ export interface BlizzardUIOptions {
 /** Opt-in stock UI visibility. Native buttons, bindings and event handlers remain intact. */
 export declare class BlizzardUI {
     private constructor();
+    /** Style native micro-menu buttons. Reload restores their original textures. */
+    static SkinMicroMenu(options?: MicroMenuSkinOptions): () => void;
+    /** Disable stock action-bar event/update paths. Restoring their scripts requires reload. */
+    static DisableActionBars(): () => void;
     /** Returns a restore function; protected changes wait until combat ends. */
     static Hide(options: BlizzardUIOptions): () => void;
 }

package/lib/platform/BlizzardUI.lua

@@ -7,16 +7,6 @@ local function __TS__Class(self)
     return c
 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 __TS__Symbol, Symbol
 do
     local symbolMetatable = {__tostring = function(self)
@@ -76,6 +66,262 @@ do
     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()
@@ -240,20 +486,111 @@ do
     end
     Map[Symbol.species] = Map
 end
-
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-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
@@ -307,11 +644,11 @@ function BlizzardUI.Hide(self, options)
         end
         for ____, name in ipairs(names) do
             do
-                local __continue14
+                local __continue31
                 repeat
                     local frame = _G[name]
                     if frame == nil then
-                        __continue14 = true
+                        __continue31 = true
                         break
                     end
                     if not parents:has(frame) then
@@ -331,9 +668,9 @@ function BlizzardUI.Hide(self, options)
                     if frame:GetParent() ~= hidden then
                         frame:SetParent(hidden)
                     end
-                    __continue14 = true
+                    __continue31 = true
                 until true
-                if not __continue14 then
+                if not __continue31 then
                     break
                 end
             end

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;