wuira 0.1.5 → 0.1.6

package/lib/datasources/ProgressSource.lua

@@ -66,7 +66,7 @@ function ProgressSource.prototype.BindTo(self, frame, options)
         options = {}
     end
     local function refresh()
-        local sourceValue = self.readers:current()
+        local sourceValue = self:GetValue()
         local active = self:CanEmit(sourceValue)
         local ____this_1
         ____this_1 = options
@@ -91,7 +91,20 @@ function ProgressSource.prototype.BindTo(self, frame, options)
         end
     end
     local dispose = self:Listen(frame, refresh)
-    refresh(nil)
+    do
+        local function ____catch(failure)
+            if dispose ~= nil then
+                dispose(nil)
+            end
+            error(failure, 0)
+        end
+        local ____try, ____hasReturned = pcall(function()
+            refresh(nil)
+        end)
+        if not ____try then
+            ____catch(____hasReturned)
+        end
+    end
     return dispose
 end
 return ____exports

package/lib/datasources/Resources.d.ts

@@ -3,15 +3,24 @@ import { UnitSource } from "./UnitSource";
 import type { UnitInput } from "./UnitSource";
 import { DataSource } from "./DataSource";
 import type { ProgressOverrides } from "./ProgressSource";
+import { ManaRegenTimer } from "./ManaRegenTimer";
 export { Unit } from "./UnitSource";
 /** Direct API-to-widget binding; opaque values are never compared or calculated. */
 declare abstract class Resource extends ProgressSource {
     private readonly unitToken;
     private readonly events;
     private readonly listeners;
+    private eventFrame?;
+    private dispatching;
+    private eventValue;
     protected constructor(current: () => number, maximum: () => number, percent: () => number, unitToken: string, events: string[]);
     protected AddEvents(...events: string[]): void;
-    protected Listen(frame: wuiraNativeFrame, refresh: () => void): () => void;
+    protected GetValue(): number;
+    /** Future readable value changes only. Unsubscribe when the consumer is removed. */
+    onChange(listener: (value: number) => void): () => void;
+    /** One native event frame is shared by widgets, observers, and accessories. */
+    protected Observe(listener: (event: string, payload: unknown[], value: number) => void): () => void;
+    protected Listen(_frame: wuiraNativeFrame, refresh: () => void): () => void;
 }
 /** Live optional prediction channel. Secret amounts only travel to native sinks. */
 export declare class HealthPrediction extends DataSource<number> {
@@ -35,6 +44,9 @@ export declare class HP extends Resource {
 }
 /** Explicit mana (power type 0), even while the unit uses rage/energy. */
 export declare class Mana extends Resource {
+    private regenTimer?;
+    get RegenTimer(): ManaRegenTimer | undefined;
+    UseRegenTimer(): this;
     readonly target: UnitSource;
     get unit(): string;
     constructor(unit: UnitInput);

package/lib/datasources/Resources.lua

@@ -489,6 +489,8 @@ local Unit = ____UnitSource.Unit
 local resolveUnit = ____UnitSource.resolveUnit
 local ____DataSource = require("datasources.DataSource")
 local DataSource = ____DataSource.DataSource
+local ____ManaRegenTimer = require("datasources.ManaRegenTimer")
+local ManaRegenTimer = ____ManaRegenTimer.ManaRegenTimer
 do
     local ____UnitSource = require("datasources.UnitSource")
     ____exports.Unit = ____UnitSource.Unit
@@ -510,6 +512,8 @@ function Resource.prototype.____constructor(self, current, maximum, percent, uni
     self.unitToken = unitToken
     self.events = events
     self.listeners = __TS__New(Set)
+    self.dispatching = false
+    self.eventValue = 0
 end
 function Resource.prototype.AddEvents(self, ...)
     local events = {...}
@@ -523,8 +527,11 @@ function Resource.prototype.AddEvents(self, ...)
                 end
                 local ____self_events_0 = self.events
                 ____self_events_0[#____self_events_0 + 1] = event
-                for ____, frame in __TS__Iterator(self.listeners) do
-                    frame:RegisterEvent(event)
+                if self.listeners.size > 0 then
+                    local ____opt_1 = self.eventFrame
+                    if ____opt_1 ~= nil then
+                        ____opt_1:RegisterEvent(event)
+                    end
                 end
                 __continue5 = true
             until true
@@ -534,26 +541,77 @@ function Resource.prototype.AddEvents(self, ...)
         end
     end
 end
-function Resource.prototype.Listen(self, frame, refresh)
-    self.listeners:add(frame)
-    frame:SetScript(
-        "OnEvent",
-        function(_frame, event, unit)
-            if event == "PLAYER_ENTERING_WORLD" or unit == self.unitToken then
-                refresh(nil)
+function Resource.prototype.GetValue(self)
+    return self.dispatching and self.eventValue or ProgressSource.prototype.GetValue(self)
+end
+function Resource.prototype.onChange(self, listener)
+    local previous = self:GetValue()
+    local readable = not issecretvalue(previous)
+    return self:Observe(function(____, _, _payload, value)
+        if issecretvalue(value) or not self:CanEmit(value) then
+            return
+        end
+        if readable and value == previous then
+            return
+        end
+        previous = value
+        readable = true
+        listener(nil, value)
+    end)
+end
+function Resource.prototype.Observe(self, listener)
+    self.listeners:add(listener)
+    if self.listeners.size == 1 then
+        if self.eventFrame == nil then
+            self.eventFrame = CreateFrame("Frame", nil, UIParent)
+        end
+        local frame = self.eventFrame
+        frame:SetScript(
+            "OnEvent",
+            function(_frame, event, ...)
+                local payload = {...}
+                if event ~= "PLAYER_ENTERING_WORLD" and (issecretvalue(payload[1]) or payload[1] ~= self.unitToken) then
+                    return
+                end
+                self.eventValue = ProgressSource.prototype.GetValue(self)
+                self.dispatching = true
+                do
+                    local ____try, ____error = pcall(function()
+                        for ____, callback in __TS__Iterator(self.listeners) do
+                            callback(nil, event, payload, self.eventValue)
+                        end
+                    end)
+                    do
+                        self.dispatching = false
+                    end
+                    if not ____try then
+                        error(____error, 0)
+                    end
+                end
             end
+        )
+        frame:RegisterEvent("PLAYER_ENTERING_WORLD")
+        for ____, event in ipairs(self.events) do
+            frame:RegisterEvent(event)
         end
-    )
-    frame:RegisterEvent("PLAYER_ENTERING_WORLD")
-    for ____, event in ipairs(self.events) do
-        frame:RegisterEvent(event)
     end
     return function()
-        self.listeners:delete(frame)
-        frame:UnregisterAllEvents()
-        frame:SetScript("OnEvent", nil)
+        self.listeners:delete(listener)
+        if self.listeners.size == 0 then
+            local ____opt_3 = self.eventFrame
+            if ____opt_3 ~= nil then
+                ____opt_3:UnregisterAllEvents()
+            end
+            local ____opt_5 = self.eventFrame
+            if ____opt_5 ~= nil then
+                ____opt_5:SetScript("OnEvent", nil)
+            end
+        end
     end
 end
+function Resource.prototype.Listen(self, _frame, refresh)
+    return self:Observe(function() return refresh(nil) end)
+end
 --- Live optional prediction channel. Secret amounts only travel to native sinks.
 ____exports.HealthPrediction = __TS__Class()
 local HealthPrediction = ____exports.HealthPrediction
@@ -564,8 +622,8 @@ function HealthPrediction.prototype.____constructor(self, read)
     self.read = read
 end
 function HealthPrediction.prototype.GetValue(self)
-    local ____opt_1 = self.read
-    local value = ____opt_1 and ____opt_1(self)
+    local ____opt_7 = self.read
+    local value = ____opt_7 and ____opt_7(self)
     if issecretvalue(value) then
         return value
     end
@@ -614,14 +672,14 @@ function HP.prototype.____constructor(self, unit)
 end
 function HP.prototype.UseHealPrediction(self)
     if self.healPrediction == nil then
-        local ____exports_HealthPrediction_4 = ____exports.HealthPrediction
-        local ____temp_3
+        local ____exports_HealthPrediction_10 = ____exports.HealthPrediction
+        local ____temp_9
         if UnitGetIncomingHeals == nil then
-            ____temp_3 = nil
+            ____temp_9 = nil
         else
-            ____temp_3 = function() return UnitGetIncomingHeals(self.unit) end
+            ____temp_9 = function() return UnitGetIncomingHeals(self.unit) end
         end
-        self.healPrediction = __TS__New(____exports_HealthPrediction_4, ____temp_3)
+        self.healPrediction = __TS__New(____exports_HealthPrediction_10, ____temp_9)
         if self.healPrediction.IsAvailable then
             self:AddEvents("UNIT_HEAL_PREDICTION")
         end
@@ -630,14 +688,14 @@ function HP.prototype.UseHealPrediction(self)
 end
 function HP.prototype.UseAbsorbPrediction(self)
     if self.absorbPrediction == nil then
-        local ____exports_HealthPrediction_6 = ____exports.HealthPrediction
-        local ____temp_5
+        local ____exports_HealthPrediction_12 = ____exports.HealthPrediction
+        local ____temp_11
         if UnitGetTotalAbsorbs == nil then
-            ____temp_5 = nil
+            ____temp_11 = nil
         else
-            ____temp_5 = function() return UnitGetTotalAbsorbs(self.unit) end
+            ____temp_11 = function() return UnitGetTotalAbsorbs(self.unit) end
         end
-        self.absorbPrediction = __TS__New(____exports_HealthPrediction_6, ____temp_5)
+        self.absorbPrediction = __TS__New(____exports_HealthPrediction_12, ____temp_11)
         if self.absorbPrediction.IsAvailable then
             self:AddEvents("UNIT_ABSORB_AMOUNT_CHANGED")
         end
@@ -661,23 +719,23 @@ function HP.prototype.BindTo(self, frame, options)
                 if options.healPredictionBar ~= nil or options.absorbPredictionBar ~= nil then
                     local maximum = UnitHealthMax(self.unit)
                     if options.healPredictionBar ~= nil then
-                        local ____opt_7 = self.healPrediction
-                        if ____opt_7 ~= nil then
-                            ____opt_7:ApplyTo(options.healPredictionBar, maximum)
+                        local ____opt_13 = self.healPrediction
+                        if ____opt_13 ~= nil then
+                            ____opt_13:ApplyTo(options.healPredictionBar, maximum)
                         end
                     end
                     if options.absorbPredictionBar ~= nil then
-                        local ____opt_9 = self.absorbPrediction
-                        if ____opt_9 ~= nil then
-                            ____opt_9:ApplyTo(options.absorbPredictionBar, maximum)
+                        local ____opt_15 = self.absorbPrediction
+                        if ____opt_15 ~= nil then
+                            ____opt_15:ApplyTo(options.absorbPredictionBar, maximum)
                         end
                     end
                 end
-                local ____this_12
-                ____this_12 = options
-                local ____opt_11 = ____this_12.onRefresh
-                if ____opt_11 ~= nil then
-                    ____opt_11(____this_12)
+                local ____this_18
+                ____this_18 = options
+                local ____opt_17 = ____this_18.onRefresh
+                if ____opt_17 ~= nil then
+                    ____opt_17(____this_18)
                 end
             end}
         )
@@ -724,6 +782,27 @@ function Mana.prototype.____constructor(self, unit)
     )
     self.target = target
 end
+function Mana.prototype.UseRegenTimer(self)
+    if self.unit ~= "player" then
+        error("Mana.UseRegenTimer: only the player is supported")
+    end
+    if self.regenTimer == nil then
+        self:AddEvents("UNIT_SPELLCAST_SUCCEEDED")
+        self.regenTimer = __TS__New(
+            ManaRegenTimer,
+            function(____, listener) return self:Observe(listener) end
+        )
+    end
+    return self
+end
+__TS__SetDescriptor(
+    Mana.prototype,
+    "RegenTimer",
+    {get = function(self)
+        return self.regenTimer
+    end},
+    true
+)
 __TS__SetDescriptor(
     Mana.prototype,
     "unit",

package/lib/datasources/SpellCooldown.d.ts

@@ -1,8 +1,10 @@
 import { TimerSource } from "./TimerSource";
 /** Native cooldown duration, including opaque timings during combat. */
 export declare class SpellCooldown extends TimerSource {
-    readonly spellId: number;
-    constructor(spellId: number);
+    readonly spellId: number | string;
+    constructor(spellId: number | string, options?: {
+        ignoreGCD?: boolean;
+    });
     get IsAvailable(): boolean;
 }
 export declare class GlobalCooldown extends SpellCooldown {

package/lib/datasources/SpellCooldown.lua

@@ -178,12 +178,23 @@ ____exports.SpellCooldown = __TS__Class()
 local SpellCooldown = ____exports.SpellCooldown
 SpellCooldown.name = "SpellCooldown"
 __TS__ClassExtends(SpellCooldown, TimerSource)
-function SpellCooldown.prototype.____constructor(self, spellId)
+function SpellCooldown.prototype.____constructor(self, spellId, options)
+    if options == nil then
+        options = {}
+    end
     TimerSource.prototype.____constructor(
         self,
         function()
             local ____opt_0 = C_Spell and C_Spell.GetSpellCooldownDuration
-            return ____opt_0 and ____opt_0(spellId)
+            if ____opt_0 ~= nil then
+                local ____spellId_2 = spellId
+                local ____options_ignoreGCD_1 = options.ignoreGCD
+                if ____options_ignoreGCD_1 == nil then
+                    ____options_ignoreGCD_1 = false
+                end
+                ____opt_0 = ____opt_0(____spellId_2, ____options_ignoreGCD_1)
+            end
+            return ____opt_0
         end,
         {"SPELL_UPDATE_COOLDOWN", "PLAYER_ENTERING_WORLD", "SPELLS_CHANGED"}
     )

package/lib/datasources/SpellSource.d.ts

@@ -0,0 +1,14 @@
+import { DataSource } from "./DataSource";
+import { TextureSource } from "./TextureSource";
+import { SpellCooldown } from "./SpellCooldown";
+import type { SecureAction } from "../ui/SecureButton";
+/** Localized spell identity, texture and native cooldown, independent of action slots. */
+export declare class SpellSource extends DataSource<string | undefined> {
+    readonly spellId: number;
+    readonly Texture: TextureSource;
+    readonly Cooldown: SpellCooldown;
+    constructor(spellId: number);
+    protected GetValue(): string | undefined;
+    get Identifier(): number | string;
+    get Action(): SecureAction;
+}

package/lib/datasources/SpellSource.lua

@@ -0,0 +1,224 @@
+--[[ 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__ClassExtends(target, base)
+    target.____super = base
+    local staticMetatable = setmetatable({__index = base}, base)
+    setmetatable(target, staticMetatable)
+    local baseMetatable = getmetatable(base)
+    if baseMetatable then
+        if type(baseMetatable.__index) == "function" then
+            staticMetatable.__index = baseMetatable.__index
+        end
+        if type(baseMetatable.__newindex) == "function" then
+            staticMetatable.__newindex = baseMetatable.__newindex
+        end
+    end
+    setmetatable(target.prototype, base.prototype)
+    if type(base.prototype.__index) == "function" then
+        target.prototype.__index = base.prototype.__index
+    end
+    if type(base.prototype.__newindex) == "function" then
+        target.prototype.__newindex = base.prototype.__newindex
+    end
+    if type(base.prototype.__tostring) == "function" then
+        target.prototype.__tostring = base.prototype.__tostring
+    end
+end
+
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+local function __TS__CloneDescriptor(____bindingPattern0)
+    local value
+    local writable
+    local set
+    local get
+    local configurable
+    local enumerable
+    enumerable = ____bindingPattern0.enumerable
+    configurable = ____bindingPattern0.configurable
+    get = ____bindingPattern0.get
+    set = ____bindingPattern0.set
+    writable = ____bindingPattern0.writable
+    value = ____bindingPattern0.value
+    local descriptor = {enumerable = enumerable == true, configurable = configurable == true}
+    local hasGetterOrSetter = get ~= nil or set ~= nil
+    local hasValueOrWritableAttribute = writable ~= nil or value ~= nil
+    if hasGetterOrSetter and hasValueOrWritableAttribute then
+        error("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute.", 0)
+    end
+    if get or set then
+        descriptor.get = get
+        descriptor.set = set
+    else
+        descriptor.value = value
+        descriptor.writable = writable == true
+    end
+    return descriptor
+end
+
+local __TS__DescriptorGet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
+        while metatable do
+            local rawResult = ____rawget(metatable, key)
+            if rawResult ~= nil then
+                return rawResult
+            end
+            local descriptors = ____rawget(metatable, "_descriptors")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.get then
+                        return descriptor.get(self)
+                    end
+                    return descriptor.value
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+    end
+end
+
+local __TS__DescriptorSet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    local rawset = _G.rawset
+    function __TS__DescriptorSet(self, metatable, key, value)
+        while metatable do
+            local descriptors = ____rawget(metatable, "_descriptors")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.set then
+                        descriptor.set(self, value)
+                    else
+                        if descriptor.writable == false then
+                            error(
+                                ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
+                                0
+                            )
+                        end
+                        descriptor.value = value
+                    end
+                    return
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+        rawset(self, key, value)
+    end
+end
+
+local __TS__SetDescriptor
+do
+    local getmetatable = _G.getmetatable
+    local function descriptorIndex(self, key)
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
+    end
+    local function descriptorNewIndex(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
+    end
+    function __TS__SetDescriptor(target, key, desc, isPrototype)
+        if isPrototype == nil then
+            isPrototype = false
+        end
+        local ____isPrototype_0
+        if isPrototype then
+            ____isPrototype_0 = target
+        else
+            ____isPrototype_0 = getmetatable(target)
+        end
+        local metatable = ____isPrototype_0
+        if not metatable then
+            metatable = {}
+            setmetatable(target, metatable)
+        end
+        if not isPrototype and not rawget(metatable, "_isOwnDescriptorMetatable") then
+            local instanceMetatable = {}
+            instanceMetatable._isOwnDescriptorMetatable = true
+            setmetatable(instanceMetatable, metatable)
+            setmetatable(target, instanceMetatable)
+            metatable = instanceMetatable
+        end
+        local value = rawget(target, key)
+        if value ~= nil then
+            rawset(target, key, nil)
+        end
+        if not rawget(metatable, "_descriptors") then
+            metatable._descriptors = {}
+        end
+        metatable._descriptors[key] = __TS__CloneDescriptor(desc)
+        metatable.__index = descriptorIndex
+        metatable.__newindex = descriptorNewIndex
+    end
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____DataSource = require("datasources.DataSource")
+local DataSource = ____DataSource.DataSource
+local ____TextureSource = require("datasources.TextureSource")
+local TextureSource = ____TextureSource.TextureSource
+local ____SpellCooldown = require("datasources.SpellCooldown")
+local SpellCooldown = ____SpellCooldown.SpellCooldown
+--- Localized spell identity, texture and native cooldown, independent of action slots.
+____exports.SpellSource = __TS__Class()
+local SpellSource = ____exports.SpellSource
+SpellSource.name = "SpellSource"
+__TS__ClassExtends(SpellSource, DataSource)
+function SpellSource.prototype.____constructor(self, spellId)
+    DataSource.prototype.____constructor(self, nil)
+    self.spellId = spellId
+    self.Texture = __TS__New(
+        TextureSource,
+        function()
+            local ____opt_0 = C_Spell and C_Spell.GetSpellTexture
+            return ____opt_0 and ____opt_0(spellId)
+        end,
+        {"SPELLS_CHANGED", "PLAYER_ENTERING_WORLD"}
+    )
+    self.Cooldown = __TS__New(SpellCooldown, self.Identifier, {ignoreGCD = true})
+end
+function SpellSource.prototype.GetValue(self)
+    local ____opt_4 = C_Spell and C_Spell.GetSpellName
+    return ____opt_4 and ____opt_4(self.spellId)
+end
+__TS__SetDescriptor(
+    SpellSource.prototype,
+    "Identifier",
+    {get = function(self)
+        return self.Value or self.spellId
+    end},
+    true
+)
+__TS__SetDescriptor(
+    SpellSource.prototype,
+    "Action",
+    {get = function(self)
+        return {type = "spell", spell = self.Identifier}
+    end},
+    true
+)
+return ____exports

package/lib/datasources/TimerSource.d.ts

@@ -14,5 +14,7 @@ export declare class TimerSource extends DataSource<NativeDuration | undefined>
     constructor(read: () => NativeDuration | undefined, events: readonly string[], unit?: string | undefined);
     protected GetValue(): NativeDuration | undefined;
     get IsActive(): boolean;
+    /** A native radial cooldown owns timing, countdown text and completion effects. */
+    BindCooldown(frame: wuiraNativeCooldown): () => void;
     BindTo(frame: wuiraNativeStatusBar, options?: ProgressOverrides): () => void;
 }

package/lib/datasources/TimerSource.lua

@@ -195,6 +195,60 @@ end
 function TimerSource.prototype.GetValue(self)
     return self:read()
 end
+function TimerSource.prototype.BindCooldown(self, frame)
+    if C_DurationUtil == nil then
+        error("TimerSource: native duration support is unavailable")
+    end
+    local empty = C_DurationUtil.CreateDuration()
+    local listener = CreateFrame("Frame", nil, UIParent)
+    local function refresh()
+        local duration = self:read()
+        self.boundDuration = duration
+        frame:SetCooldownFromDurationObject(
+            self:CanEmit(duration) and (duration or empty) or empty,
+            true
+        )
+    end
+    listener:SetScript(
+        "OnEvent",
+        function(_frame, event, unit)
+            if not __TS__StringStartsWith(event, "UNIT_") or self.unit == nil or unit == self.unit then
+                refresh(nil)
+            end
+        end
+    )
+    for ____, event in ipairs(self.events) do
+        listener:RegisterEvent(event)
+    end
+    self.bindingCount = self.bindingCount + 1
+    do
+        local function ____catch(failure)
+            self.bindingCount = self.bindingCount - 1
+            listener:UnregisterAllEvents()
+            listener:SetScript("OnEvent", nil)
+            error(failure, 0)
+        end
+        local ____try, ____hasReturned = pcall(function()
+            refresh(nil)
+        end)
+        if not ____try then
+            ____catch(____hasReturned)
+        end
+    end
+    local disposed = false
+    return function()
+        if disposed then
+            return
+        end
+        disposed = true
+        self.bindingCount = self.bindingCount - 1
+        listener:UnregisterAllEvents()
+        listener:SetScript("OnEvent", nil)
+        listener:Hide()
+        frame:SetDrawBling(false)
+        frame:Clear()
+    end
+end
 function TimerSource.prototype.BindTo(self, frame, options)
     if options == nil then
         options = {}

package/lib/datasources/TotemTimer.d.ts

@@ -0,0 +1,10 @@
+import { TimerSource } from "./TimerSource";
+export type TotemTimerStatus = "active" | "inactive" | "restricted" | "unavailable";
+/** Player-owned ground effects exposed by the game's totem API, across spell ranks. */
+export declare class TotemTimer extends TimerSource {
+    readonly spell: number | string;
+    private status;
+    constructor(spell: number | string);
+    get Status(): TotemTimerStatus;
+    private ReadDuration;
+}