wuira 0.1.3 → 0.1.5

package/lib/datasources/CastTimer.lua

@@ -0,0 +1,240 @@
+--[[ 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 __TS__Unpack = table.unpack or unpack
+
+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 ____TimerSource = require("datasources.TimerSource")
+local TimerSource = ____TimerSource.TimerSource
+local ____UnitSource = require("datasources.UnitSource")
+local Unit = ____UnitSource.Unit
+local resolveUnit = ____UnitSource.resolveUnit
+--- Remaining cast/channel time using the native duration object.
+____exports.CastTimer = __TS__Class()
+local CastTimer = ____exports.CastTimer
+CastTimer.name = "CastTimer"
+__TS__ClassExtends(CastTimer, TimerSource)
+function CastTimer.prototype.____constructor(self, unit)
+    if unit == nil then
+        unit = Unit.Player
+    end
+    local target = resolveUnit(nil, unit)
+    if UnitCastingDuration == nil or UnitChannelDuration == nil then
+        error("CastTimer: native cast/channel durations are unavailable")
+    end
+    TimerSource.prototype.____constructor(
+        self,
+        function()
+            local casting = UnitCastingDuration(target.Token)
+            if issecretvalue(casting) or casting ~= nil then
+                return casting
+            end
+            return UnitChannelDuration(target.Token)
+        end,
+        {
+            "UNIT_SPELLCAST_START",
+            "UNIT_SPELLCAST_STOP",
+            "UNIT_SPELLCAST_DELAYED",
+            "UNIT_SPELLCAST_INTERRUPTED",
+            "UNIT_SPELLCAST_FAILED",
+            "UNIT_SPELLCAST_SUCCEEDED",
+            "UNIT_SPELLCAST_CHANNEL_START",
+            "UNIT_SPELLCAST_CHANNEL_UPDATE",
+            "UNIT_SPELLCAST_CHANNEL_STOP",
+            "PLAYER_ENTERING_WORLD",
+            "PLAYER_TARGET_CHANGED",
+            "PLAYER_FOCUS_CHANGED"
+        },
+        target.Token
+    )
+    self.target = target
+end
+__TS__SetDescriptor(
+    CastTimer.prototype,
+    "SpellName",
+    {get = function(self)
+        local casting = __TS__Unpack(UnitCastingInfo ~= nil and ({UnitCastingInfo(self.target.Token)}) or ({nil}))
+        if issecretvalue(casting) then
+            return casting
+        end
+        if casting ~= nil then
+            return casting
+        end
+        local channel = __TS__Unpack(UnitChannelInfo ~= nil and ({UnitChannelInfo(self.target.Token)}) or ({nil}))
+        if issecretvalue(channel) then
+            return channel
+        end
+        return channel or ""
+    end},
+    true
+)
+return ____exports

package/lib/datasources/DataSource.d.ts

@@ -2,12 +2,16 @@
 export declare abstract class DataSource<T> {
     private value;
     private secret;
+    private conditions?;
     protected constructor(value: T, secret?: boolean);
     /** Checked when consumed, rather than inferred from combat state. */
     IsSecret(): boolean;
     get Value(): T;
     Compute<TResult>(compute: (value: T) => TResult): TResult;
     protected GetValue(): T;
+    /** Filters native binding emissions; Value remains a checked, fresh snapshot. */
+    When(condition: (value: T) => boolean): this;
+    protected CanEmit(value: T): boolean;
     private IsValueSecret;
     /** Replace the value and its explicit restriction together, clearing stale flags. */
     protected SetValue(value: T, secret?: boolean): void;

package/lib/datasources/DataSource.lua

@@ -168,6 +168,30 @@ end
 function DataSource.prototype.GetValue(self)
     return self.value
 end
+function DataSource.prototype.When(self, condition)
+    local ____self_0, ____conditions_1 = self, "conditions"
+    if ____self_0[____conditions_1] == nil then
+        ____self_0[____conditions_1] = {}
+    end
+    local ____self_conditions_3 = self.conditions
+    ____self_conditions_3[#____self_conditions_3 + 1] = condition
+    return self
+end
+function DataSource.prototype.CanEmit(self, value)
+    if self.conditions == nil then
+        return true
+    end
+    if self:IsValueSecret(value) then
+        return false
+    end
+    for ____, condition in ipairs(self.conditions) do
+        local result = condition(nil, value)
+        if issecretvalue(result) or not result then
+            return false
+        end
+    end
+    return true
+end
 function DataSource.prototype.IsValueSecret(self, value)
     return issecretvalue(value) or self.secret or self:HasSecretFields(value)
 end

package/lib/datasources/ProgressSource.d.ts

@@ -3,6 +3,10 @@ export interface ProgressOverrides {
     min?: number;
     max?: number;
     current?: number;
+    onActiveChange?: (active: boolean) => void;
+    onRefresh?: () => void;
+    healPredictionBar?: wuiraNativeStatusBar;
+    absorbPredictionBar?: wuiraNativeStatusBar;
 }
 /** Shared contract for health, power, cooldowns, and other progress values. */
 export declare abstract class ProgressSource extends DataSource<number> {
@@ -18,6 +22,6 @@ export declare abstract class ProgressSource extends DataSource<number> {
     });
     protected GetValue(): number;
     IsSecret(): boolean;
-    BindTo(frame: wuiraNativeStatusBar, options?: ProgressOverrides): void;
-    protected abstract Listen(frame: wuiraNativeFrame, refresh: () => void): void;
+    BindTo(frame: wuiraNativeStatusBar, options?: ProgressOverrides): void | (() => void);
+    protected abstract Listen(frame: wuiraNativeFrame, refresh: () => void): void | (() => void);
 }

package/lib/datasources/ProgressSource.lua

@@ -66,14 +66,32 @@ function ProgressSource.prototype.BindTo(self, frame, options)
         options = {}
     end
     local function refresh()
-        local current = options.current ~= nil and options.current or self.readers:current()
+        local sourceValue = self.readers:current()
+        local active = self:CanEmit(sourceValue)
+        local ____this_1
+        ____this_1 = options
+        local ____opt_0 = ____this_1.onActiveChange
+        if ____opt_0 ~= nil then
+            ____opt_0(____this_1, active)
+        end
+        if not active then
+            return
+        end
+        local current = options.current ~= nil and options.current or sourceValue
         frame:SetMinMaxValues(
             options.min ~= nil and options.min or self.readers:min(),
             options.max ~= nil and options.max or self.readers:max()
         )
         frame:SetValue(current)
+        local ____this_3
+        ____this_3 = options
+        local ____opt_2 = ____this_3.onRefresh
+        if ____opt_2 ~= nil then
+            ____opt_2(____this_3)
+        end
     end
-    self:Listen(frame, refresh)
+    local dispose = self:Listen(frame, refresh)
     refresh(nil)
+    return dispose
 end
 return ____exports

package/lib/datasources/Resources.d.ts

@@ -1,18 +1,37 @@
 import { ProgressSource } from "./ProgressSource";
 import { UnitSource } from "./UnitSource";
 import type { UnitInput } from "./UnitSource";
+import { DataSource } from "./DataSource";
+import type { ProgressOverrides } from "./ProgressSource";
 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;
     protected constructor(current: () => number, maximum: () => number, percent: () => number, unitToken: string, events: string[]);
-    protected Listen(frame: wuiraNativeFrame, refresh: () => void): void;
+    protected AddEvents(...events: string[]): 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> {
+    private readonly read;
+    constructor(read: (() => number | undefined) | undefined);
+    get IsAvailable(): boolean;
+    protected GetValue(): number;
+    ApplyTo(frame: wuiraNativeStatusBar, maximum: number): void;
 }
 export declare class HP extends Resource {
+    private healPrediction?;
+    private absorbPrediction?;
+    get HealPrediction(): HealthPrediction | undefined;
+    get AbsorbPrediction(): HealthPrediction | undefined;
+    UseHealPrediction(): this;
+    UseAbsorbPrediction(): this;
+    BindTo(frame: wuiraNativeStatusBar, options?: ProgressOverrides): () => void;
     readonly target: UnitSource;
     get unit(): string;
-    constructor(unit: UnitInput);
+    constructor(unit?: UnitInput);
 }
 /** Explicit mana (power type 0), even while the unit uses rage/energy. */
 export declare class Mana extends Resource {