wuira 0.1.3 → 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/store/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference path="../platform/forever.d.ts" />
+/** Extend with data fields and defaults. A stable static Token opts into persistence. */
+export declare abstract class Store {
+}
+export interface StoreClass<T extends Store> {
+    new (): T;
+    readonly Token?: string;
+}
+export type ReadonlyData<T> = T extends object ? {
+    readonly [K in keyof T]: ReadonlyData<T[K]>;
+} : T;
+export interface SavedStoreOptions {
+    addon: string;
+    variable: string;
+}
+export declare class StoreRegistry {
+    private readonly options?;
+    private readonly memory;
+    private readonly observers;
+    private readonly tokens;
+    private readonly updating;
+    private saved?;
+    private listener?;
+    private readyCallbacks;
+    constructor(options?: SavedStoreOptions | undefined);
+    private Load;
+    get IsReady(): boolean;
+    onReady(callback: () => void): void;
+    private Read;
+    /** One-time detached snapshot, with no subscription or mutable access to stored data. */
+    get<T extends Store>(schema: StoreClass<T>): ReadonlyData<T>;
+    /** Commit only after the updater succeeds; observers receive detached snapshots. */
+    set<T extends Store>(schema: StoreClass<T>, update: (settings: T) => T): void;
+    /** Observe future commits. Call get() separately for the initial snapshot. */
+    subscribe<T extends Store>(schema: StoreClass<T>, observer: (settings: ReadonlyData<T>) => void): () => void;
+    Dispose(): void;
+}