wuira 0.1.4 → 0.1.5

package/lib/platform/BlizzardUI.lua

@@ -0,0 +1,352 @@
+--[[ 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 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)
+        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
+-- End of Lua Library inline imports
+local ____exports = {}
+--- 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.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 __continue14
+                repeat
+                    local frame = _G[name]
+                    if frame == nil then
+                        __continue14 = 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
+                    __continue14 = true
+                until true
+                if not __continue14 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/forever.d.ts

@@ -5,7 +5,7 @@ type wuiraDrawLayer = "BACKGROUND" | "OVERLAY";
 interface wuiraNativeTexture {
     SetAllPoints(frame: wuiraNativeFrame): void;
     SetColorTexture(red: number, green: number, blue: number, alpha: number): void;
-    SetTexture(path: string): void;
+    SetTexture(path: string | number | undefined): void;
     SetVertexColor(red: number, green: number, blue: number, alpha: number): void;
     SetBlendMode(mode: import("../types/Texture").BlendMode): void;
     SetHorizTile(enabled: boolean): void;
@@ -20,14 +20,19 @@ interface wuiraNativeTexture {
 }
 
 interface wuiraNativeFrame {
+    SetClipsChildren(clips: boolean): void;
+    GetFrameLevel(): number;
+    SetFrameLevel(level: number): void;
+    CreateFontString(name: undefined, layer: "OVERLAY"): wuiraNativeFontString;
     EnableMouse(enabled: boolean): void;
     RegisterEvent(event: string): void;
     UnregisterAllEvents(): void;
     SetScript(script: "OnEvent", handler: ((this: void, frame: wuiraNativeFrame, event: string, unit?: string) => void) | undefined): void;
+    SetScript(script: "OnUpdate", handler: ((this: void, frame: wuiraNativeFrame, elapsed: number) => void) | undefined): void;
     GetWidth(): number;
     GetHeight(): number;
     SetSize(width: number, height: number): void;
-    SetPoint(point: wuiraAnchor, relativeTo: wuiraNativeFrame, relativePoint: wuiraAnchor, x: number, y: number): void;
+    SetPoint(point: wuiraAnchor, relativeTo: wuiraNativeFrame | wuiraNativeTexture, relativePoint: wuiraAnchor, x: number, y: number): void;
     CreateTexture(name: undefined, layer: wuiraDrawLayer): wuiraNativeTexture;
     Show(): void;
     Hide(): void;
@@ -38,6 +43,15 @@ interface wuiraNativeFrame {
     SetBackdropBorderColor(red: number, green: number, blue: number, alpha: number): void;
 }
 
+interface wuiraNativeFontString {
+    SetAllPoints(frame: wuiraNativeFrame): void;
+    SetFont(path: string, size: number, flags?: string): boolean;
+    SetText(text: string): void;
+    SetTextColor(r: number, g: number, b: number, a: number): void;
+    SetJustifyH(align: "LEFT" | "CENTER" | "RIGHT"): void;
+    SetJustifyV(align: "MIDDLE"): void;
+}
+
 declare const UIParent: wuiraNativeFrame;
 interface wuiraNativeStatusBar extends wuiraNativeFrame {
     GetStatusBarTexture(): wuiraNativeTexture;
@@ -55,8 +69,32 @@ declare function error(this: void, message: string): never;
 declare function issecretvalue(this: void, value: unknown): boolean;
 declare function UnitHealth(this: void, unit: string): number;
 declare function UnitHealthMax(this: void, unit: string): number;
+declare const UnitGetIncomingHeals: ((this: void, unit: string) => number | undefined) | undefined;
+declare const UnitGetTotalAbsorbs: ((this: void, unit: string) => number | undefined) | undefined;
 declare function UnitPower(this: void, unit: string, powerType: number): number;
 declare function UnitPowerMax(this: void, unit: string, powerType: number): number;
 declare const CurveConstants: { readonly ScaleTo100: unknown };
 declare function UnitHealthPercent(this: void, unit: string, predicted: boolean, curve: unknown): number;
 declare function UnitPowerPercent(this: void, unit: string, powerType: number, predicted: boolean, curve: unknown): number;
+
+interface wuiraNativeAuraData {
+    name?: string;
+    icon?: number;
+    auraInstanceID?: number;
+    duration?: number;
+    expirationTime?: number;
+}
+declare const C_UnitAuras: {
+    GetAuraDataBySpellName?: (this: void, unit: string, name: string, filter: string) => wuiraNativeAuraData | undefined;
+    GetAuraDuration?: (this: void, unit: string, id: number) => import("../datasources/TimerSource").NativeDuration | undefined;
+} | undefined;
+declare const C_Spell: {
+    GetSpellName?: (this: void, id: number) => string | undefined;
+    GetSpellCooldownDuration?: (this: void, id: number) => import("../datasources/TimerSource").NativeDuration | undefined;
+} | undefined;
+declare const C_DurationUtil: {
+    CreateDuration(this: void): import("../datasources/TimerSource").NativeDuration & {
+        SetTimeFromStart(start: number, duration: number): void;
+    };
+} | undefined;
+declare const C_Secrets: { ShouldAurasBeSecret?: (this: void) => boolean } | undefined;

package/lib/ui/Cell.d.ts

@@ -14,9 +14,11 @@ export type CellProps = {
     /** Defaults to true: visual cells do not intercept mouse input. */
     clickThrough?: boolean;
     decorations?: Decorations;
+    /** Visibility does not remove the cell's reserved layout slot. */
+    visible?: () => boolean;
 } & Position<ICell>;
 export interface ICell extends Element {
-    kind: "cell" | "flow" | "grid" | "progress";
+    kind: "cell" | "flow" | "grid" | "progress" | "label" | "icon";
     props: CellProps;
 }
 export declare function Cell(props: Partial<CellProps> & {

package/lib/ui/Icon.d.ts

@@ -0,0 +1,8 @@
+import type { CellProps } from "./Cell";
+import type { TextureSource } from "../datasources/TextureSource";
+export type IconProps = CellProps & {
+    texture?: string | number;
+    textureSource?: TextureSource;
+    texCoords?: readonly [number, number, number, number];
+};
+export declare function Icon(props: Partial<IconProps>): import("..").Element;

package/lib/ui/Icon.lua

@@ -0,0 +1,8 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+local ____exports = {}
+local ____jsx = require("ui.primitives.jsx")
+local UI = ____jsx.UI
+function ____exports.Icon(self, props)
+    return UI:createElement("icon", props)
+end
+return ____exports

package/lib/ui/Label.d.ts

@@ -0,0 +1,10 @@
+import type { CellProps } from "./Cell";
+import type { Color } from "../types/Color";
+export type LabelProps = CellProps & {
+    text: string | (() => string);
+    font?: string;
+    fontSize?: number;
+    color?: Color;
+    align?: "LEFT" | "CENTER" | "RIGHT";
+};
+export declare function Label(props: Partial<CellProps> & Omit<LabelProps, keyof CellProps>): import("..").Element;

package/lib/ui/Label.lua

@@ -0,0 +1,8 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+local ____exports = {}
+local ____jsx = require("ui.primitives.jsx")
+local UI = ____jsx.UI
+function ____exports.Label(self, props)
+    return UI:createElement("label", props)
+end
+return ____exports

package/lib/ui/ProgressBar.d.ts

@@ -1,6 +1,7 @@
 import type { CellProps, ICell } from "./Cell";
 import type { Color } from "../types/Color";
 import type { ProgressSource } from "../datasources/ProgressSource";
+import type { TimerSource } from "../datasources/TimerSource";
 import { Element } from "./primitives/jsx";
 import type { TextureOptions } from "../types/Texture";
 import type { BackgroundProps } from "./decorations/Background";
@@ -8,12 +9,15 @@ import type { BorderProps } from "./decorations/Border";
 export type ProgressBarProps = CellProps & {
     value?: number;
     current?: number;
-    source?: ProgressSource;
+    source?: ProgressSource | TimerSource;
     min?: number;
     max?: number;
     color?: Color;
     /** Fill settings; explicit fields take priority over color/texture aliases. */
     foreground?: TextureOptions;
+    /** Enabled HP channels render automatically; false suppresses their overlay. */
+    healPrediction?: TextureOptions | false;
+    absorbPrediction?: TextureOptions | false;
     /** Full-size track behind the fill. false disables a decoration background. */
     background?: BackgroundProps | false;
     /** Backdrop edge texture; track/background is configured independently. */

package/lib/ui/index.d.ts

@@ -9,3 +9,7 @@ export { ProgressBar } from "./ProgressBar";
 export { Background } from "./decorations/Background";
 export { Border } from "./decorations/Border";
 export { Glow } from "./decorations/Glow";
+export { Label } from "./Label";
+export type { LabelProps } from "./Label";
+export { Icon } from "./Icon";
+export type { IconProps } from "./Icon";

package/lib/ui/index.lua

@@ -32,4 +32,12 @@ do
     local ____Glow = require("ui.decorations.Glow")
     ____exports.Glow = ____Glow.Glow
 end
+do
+    local ____Label = require("ui.Label")
+    ____exports.Label = ____Label.Label
+end
+do
+    local ____Icon = require("ui.Icon")
+    ____exports.Icon = ____Icon.Icon
+end
 return ____exports

package/lib/ui/layout/measureLayout.lua

@@ -102,7 +102,14 @@ function ____exports.measureLayout(self, element, available, ancestors)
     if __TS__ArrayIncludes(ancestors, element) then
         error("Layout children contain a cycle")
     end
-    if element.kind ~= "cell" and element.kind ~= "flow" and element.kind ~= "grid" and element.kind ~= "progress" then
+    if not __TS__ArrayIncludes({
+        "cell",
+        "flow",
+        "grid",
+        "progress",
+        "label",
+        "icon"
+    }, element.kind) then
         error("Unsupported UI element: " .. element.kind)
     end
     local cell = element