wuira 0.3.0 → 0.3.3

package/lib/datasources/Resources.lua

@@ -487,10 +487,13 @@ local ProgressSource = ____ProgressSource.ProgressSource
 local ____UnitSource = require("datasources.UnitSource")
 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
+local ____Source = require("datasources.Source")
+local Source = ____Source.Source
+local registerSource = ____Source.registerSource
+local ____UseSource = require("datasources.UseSource")
+local UseSource = ____UseSource.UseSource
 do
     local ____UnitSource = require("datasources.UnitSource")
     ____exports.Unit = ____UnitSource.Unit
@@ -621,24 +624,24 @@ 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
-HealthPrediction.name = "HealthPrediction"
-__TS__ClassExtends(HealthPrediction, DataSource)
-function HealthPrediction.prototype.____constructor(self, read)
-    DataSource.prototype.____constructor(self, 0)
-    self.read = read
-end
-function HealthPrediction.prototype.GetValue(self)
-    local ____opt_9 = self.read
-    local value = ____opt_9 and ____opt_9(self)
+local function unitToken(self, unit)
+    return type(unit) == "string" and unit or unit.Token
+end
+local function nativeAmount(self, value)
     if issecretvalue(value) then
         return value
     end
     return value or 0
 end
-function HealthPrediction.prototype.ApplyTo(self, frame, maximum)
+--- One optional unit amount. A missing native function stays unavailable and is never called.
+local UnitAmount = __TS__Class()
+UnitAmount.name = "UnitAmount"
+__TS__ClassExtends(UnitAmount, Source)
+function UnitAmount.prototype.____constructor(self, unit)
+    Source.prototype.____constructor(self, 0, unit)
+    self.target = resolveUnit(nil, unit)
+end
+function UnitAmount.prototype.ApplyTo(self, frame, maximum)
     if not self.IsAvailable then
         frame:Hide()
         return
@@ -653,13 +656,70 @@ function HealthPrediction.prototype.ApplyTo(self, frame, maximum)
     frame:Show()
 end
 __TS__SetDescriptor(
-    HealthPrediction.prototype,
+    UnitAmount.prototype,
     "IsAvailable",
     {get = function(self)
-        return self.read ~= nil
     end},
     true
 )
+--- Total absorbs on a unit. `UnitGetTotalAbsorbs`.
+____exports.Absorb = __TS__Class()
+local Absorb = ____exports.Absorb
+Absorb.name = "Absorb"
+__TS__ClassExtends(Absorb, UnitAmount)
+function Absorb.prototype.____constructor(self, unit)
+    UnitAmount.prototype.____constructor(self, unit)
+end
+function Absorb.prototype.read(self, props)
+    return UnitGetTotalAbsorbs == nil and 0 or nativeAmount(
+        nil,
+        UnitGetTotalAbsorbs(unitToken(nil, props[1]))
+    )
+end
+__TS__SetDescriptor(
+    Absorb.prototype,
+    "IsAvailable",
+    {get = function(self)
+        return UnitGetTotalAbsorbs ~= nil
+    end},
+    true
+);
+(function(self)
+    registerSource(
+        nil,
+        ____exports.Absorb,
+        function(____, props) return __TS__New(____exports.Absorb, props[1]) end
+    )
+end)(Absorb)
+--- Incoming heals on a unit. `UnitGetIncomingHeals`.
+____exports.Prediction = __TS__Class()
+local Prediction = ____exports.Prediction
+Prediction.name = "Prediction"
+__TS__ClassExtends(Prediction, UnitAmount)
+function Prediction.prototype.____constructor(self, unit)
+    UnitAmount.prototype.____constructor(self, unit)
+end
+function Prediction.prototype.read(self, props)
+    return UnitGetIncomingHeals == nil and 0 or nativeAmount(
+        nil,
+        UnitGetIncomingHeals(unitToken(nil, props[1]))
+    )
+end
+__TS__SetDescriptor(
+    Prediction.prototype,
+    "IsAvailable",
+    {get = function(self)
+        return UnitGetIncomingHeals ~= nil
+    end},
+    true
+);
+(function(self)
+    registerSource(
+        nil,
+        ____exports.Prediction,
+        function(____, props) return __TS__New(____exports.Prediction, props[1]) end
+    )
+end)(Prediction)
 ____exports.HP = __TS__Class()
 local HP = ____exports.HP
 HP.name = "HP"
@@ -679,38 +739,30 @@ function HP.prototype.____constructor(self, unit)
     )
     self.target = target
 end
-function HP.prototype.UseHealPrediction(self)
-    if self.healPrediction == nil then
-        local ____exports_HealthPrediction_12 = ____exports.HealthPrediction
-        local ____temp_11
-        if UnitGetIncomingHeals == nil then
-            ____temp_11 = nil
-        else
-            ____temp_11 = function() return UnitGetIncomingHeals(self.unit) end
-        end
-        self.healPrediction = __TS__New(____exports_HealthPrediction_12, ____temp_11)
-        if self.healPrediction.IsAvailable then
-            self:AddEvents("UNIT_HEAL_PREDICTION")
+function HP.prototype.UseAbsorb(self)
+    if self.absorb == nil then
+        self.absorb = UseSource(nil, ____exports.Absorb, self.target)
+        if self.absorb.IsAvailable then
+            self:AddEvents("UNIT_ABSORB_AMOUNT_CHANGED")
         end
     end
     return self
 end
-function HP.prototype.UseAbsorbPrediction(self)
-    if self.absorbPrediction == nil then
-        local ____exports_HealthPrediction_14 = ____exports.HealthPrediction
-        local ____temp_13
-        if UnitGetTotalAbsorbs == nil then
-            ____temp_13 = nil
-        else
-            ____temp_13 = function() return UnitGetTotalAbsorbs(self.unit) end
-        end
-        self.absorbPrediction = __TS__New(____exports_HealthPrediction_14, ____temp_13)
-        if self.absorbPrediction.IsAvailable then
-            self:AddEvents("UNIT_ABSORB_AMOUNT_CHANGED")
+function HP.prototype.UsePrediction(self)
+    if self.prediction == nil then
+        self.prediction = UseSource(nil, ____exports.Prediction, self.target)
+        if self.prediction.IsAvailable then
+            self:AddEvents("UNIT_HEAL_PREDICTION")
         end
     end
     return self
 end
+function HP.prototype.UseAbsorbPrediction(self)
+    return self:UseAbsorb()
+end
+function HP.prototype.UseHealPrediction(self)
+    return self:UsePrediction()
+end
 function HP.prototype.BindTo(self, frame, options)
     if options == nil then
         options = {}
@@ -728,23 +780,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_15 = self.healPrediction
-                        if ____opt_15 ~= nil then
-                            ____opt_15:ApplyTo(options.healPredictionBar, maximum)
+                        local ____opt_9 = self.prediction
+                        if ____opt_9 ~= nil then
+                            ____opt_9:ApplyTo(options.healPredictionBar, maximum)
                         end
                     end
                     if options.absorbPredictionBar ~= nil then
-                        local ____opt_17 = self.absorbPrediction
-                        if ____opt_17 ~= nil then
-                            ____opt_17:ApplyTo(options.absorbPredictionBar, maximum)
+                        local ____opt_11 = self.absorb
+                        if ____opt_11 ~= nil then
+                            ____opt_11:ApplyTo(options.absorbPredictionBar, maximum)
                         end
                     end
                 end
-                local ____this_20
-                ____this_20 = options
-                local ____opt_19 = ____this_20.onRefresh
-                if ____opt_19 ~= nil then
-                    ____opt_19(____this_20)
+                local ____this_14
+                ____this_14 = options
+                local ____opt_13 = ____this_14.onRefresh
+                if ____opt_13 ~= nil then
+                    ____opt_13(____this_14)
                 end
             end}
         )
@@ -752,9 +804,17 @@ function HP.prototype.BindTo(self, frame, options)
 end
 __TS__SetDescriptor(
     HP.prototype,
-    "HealPrediction",
+    "Absorb",
+    {get = function(self)
+        return self.absorb
+    end},
+    true
+)
+__TS__SetDescriptor(
+    HP.prototype,
+    "Prediction",
     {get = function(self)
-        return self.healPrediction
+        return self.prediction
     end},
     true
 )
@@ -762,7 +822,15 @@ __TS__SetDescriptor(
     HP.prototype,
     "AbsorbPrediction",
     {get = function(self)
-        return self.absorbPrediction
+        return self.absorb
+    end},
+    true
+)
+__TS__SetDescriptor(
+    HP.prototype,
+    "HealPrediction",
+    {get = function(self)
+        return self.prediction
     end},
     true
 )
@@ -773,7 +841,14 @@ __TS__SetDescriptor(
         return self.target.Token
     end},
     true
-)
+);
+(function(self)
+    registerSource(
+        nil,
+        ____exports.HP,
+        function(____, props) return __TS__New(____exports.HP, props[1]) end
+    )
+end)(HP)
 --- Explicit mana (power type 0), even while the unit uses rage/energy.
 ____exports.Mana = __TS__Class()
 local Mana = ____exports.Mana
@@ -797,7 +872,8 @@ function Mana.prototype.UseRegenTimer(self)
     end
     if self.regenTimer == nil then
         self:AddEvents("UNIT_SPELLCAST_SUCCEEDED")
-        self.regenTimer = __TS__New(
+        self.regenTimer = UseSource(
+            nil,
             ManaRegenTimer,
             function(____, listener) return self:Observe(listener) end
         )
@@ -819,6 +895,13 @@ __TS__SetDescriptor(
         return self.target.Token
     end},
     true
-)
+);
+(function(self)
+    registerSource(
+        nil,
+        ____exports.Mana,
+        function(____, props) return __TS__New(____exports.Mana, props[1]) end
+    )
+end)(Mana)
 ____exports.DataSources = {Resources = {HP = ____exports.HP, Mana = ____exports.Mana}}
 return ____exports

package/lib/datasources/Source.d.ts

@@ -0,0 +1,18 @@
+import { DataSource } from "./DataSource";
+/** Lets a protected constructor stay closed while UseSource can still open it. */
+export declare function registerSource(ctor: Function, open: (props: readonly unknown[]) => unknown): boolean;
+export declare function openSource(ctor: Function, props: readonly unknown[]): unknown;
+/** Opens a registered source. Public call sites use the typed overloads in UseSource.ts. */
+export declare function UseSource<T>(source: {
+    prototype: T;
+}, ...props: unknown[]): T;
+/**
+ * One query. Construction stores the props; every read passes those same props back in.
+ * The source value is the reading.
+ */
+export declare abstract class Source<TReading, TProps extends readonly unknown[] = []> extends DataSource<TReading> {
+    protected readonly props: TProps;
+    protected constructor(initial: TReading, ...props: TProps);
+    protected abstract read(props: TProps): TReading;
+    protected GetValue(): TReading;
+}

package/lib/datasources/Source.lua

@@ -0,0 +1,300 @@
+--[[ 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 __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
+
+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
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____DataSource = require("datasources.DataSource")
+local DataSource = ____DataSource.DataSource
+local openers = __TS__New(Map)
+--- Lets a protected constructor stay closed while UseSource can still open it.
+function ____exports.registerSource(self, ctor, open)
+    openers:set(ctor, open)
+    return true
+end
+function ____exports.openSource(self, ctor, props)
+    local open = openers:get(ctor)
+    if open == nil then
+        error("UseSource: this source is not registered")
+    end
+    return open(nil, props)
+end
+--- Opens a registered source. Public call sites use the typed overloads in UseSource.ts.
+function ____exports.UseSource(self, source, ...)
+    local props = {...}
+    return ____exports.openSource(nil, source, props)
+end
+--- One query. Construction stores the props; every read passes those same props back in.
+-- The source value is the reading.
+____exports.Source = __TS__Class()
+local Source = ____exports.Source
+Source.name = "Source"
+__TS__ClassExtends(Source, DataSource)
+function Source.prototype.____constructor(self, initial, ...)
+    local props = {...}
+    DataSource.prototype.____constructor(self, initial)
+    self.props = props
+end
+function Source.prototype.GetValue(self)
+    return self:read(self.props)
+end
+return ____exports

package/lib/datasources/SourceConverter.d.ts

@@ -17,7 +17,7 @@ export declare class SourceConverter<TInput, TOutput> extends DataSource<TOutput
     private blocked;
     private previous?;
     private readable;
-    constructor(input: ValueSource<TInput>, convert: (value: TInput) => TOutput);
+    protected constructor(input: ValueSource<TInput>, convert: (value: TInput) => TOutput);
     protected GetValue(): TOutput;
     private Convert;
     protected HasSecretFields(value: TOutput): boolean;

package/lib/datasources/SourceConverter.lua

@@ -323,6 +323,8 @@ end
 local ____exports = {}
 local ____DataSource = require("datasources.DataSource")
 local DataSource = ____DataSource.DataSource
+local ____Source = require("datasources.Source")
+local registerSource = ____Source.registerSource
 local function restricted(self, value, seen, depth)
     if seen == nil then
         seen = __TS__New(Set)
@@ -471,5 +473,12 @@ function SourceConverter.prototype.Dispose(self)
     end
     self.stop = nil
     self.listeners:clear()
-end
+end;
+(function(self)
+    registerSource(
+        nil,
+        ____exports.SourceConverter,
+        function(____, props) return __TS__New(____exports.SourceConverter, props[1], props[2]) end
+    )
+end)(SourceConverter)
 return ____exports

package/lib/datasources/SpellCooldown.d.ts

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