wuira 0.1.2 → 0.1.4

package/lib/datasources/GroupMembers.lua

@@ -0,0 +1,122 @@
+--[[ 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__NumberIsFinite(value)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+end
+
+local function __TS__NumberIsInteger(value)
+    return __TS__NumberIsFinite(value) and math.floor(value) == value
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____DataSource = require("datasources.DataSource")
+local DataSource = ____DataSource.DataSource
+--- Fresh roster tokens, including offline members. Tokens are not persistent identities.
+____exports.GroupMembers = __TS__Class()
+local GroupMembers = ____exports.GroupMembers
+GroupMembers.name = "GroupMembers"
+__TS__ClassExtends(GroupMembers, DataSource)
+function GroupMembers.prototype.____constructor(self, scope)
+    if scope == nil then
+        scope = "auto"
+    end
+    DataSource.prototype.____constructor(self, {})
+    self.scope = scope
+    self.restricted = false
+end
+function GroupMembers.prototype.HasSecretFields(self)
+    return self.restricted
+end
+function GroupMembers.prototype.GetValue(self)
+    self.restricted = false
+    if IsInRaid == nil or GetNumGroupMembers == nil then
+        error("GroupMembers: this client does not expose the required group APIs")
+    end
+    local raid = IsInRaid()
+    local count = GetNumGroupMembers()
+    if issecretvalue(raid) or issecretvalue(count) then
+        self.restricted = true
+        return {}
+    end
+    if not __TS__NumberIsInteger(count) or count < 0 or count > 1024 then
+        error("GroupMembers: invalid group member count")
+    end
+    if raid then
+        if self.scope == "party" then
+            return {}
+        end
+        local units = {}
+        do
+            local index = 1
+            while index <= count do
+                units[#units + 1] = "raid" .. tostring(index)
+                index = index + 1
+            end
+        end
+        return units
+    end
+    if self.scope == "raid" then
+        return {}
+    end
+    if count == 0 then
+        return self.scope == "auto" and ({"player"}) or ({})
+    end
+    local units = {"player"}
+    do
+        local index = 1
+        while index < count do
+            units[#units + 1] = "party" .. tostring(index)
+            index = index + 1
+        end
+    end
+    return units
+end
+--- Includes the player in a party; empty when solo or in a raid.
+____exports.PartyMembers = __TS__Class()
+local PartyMembers = ____exports.PartyMembers
+PartyMembers.name = "PartyMembers"
+__TS__ClassExtends(PartyMembers, ____exports.GroupMembers)
+function PartyMembers.prototype.____constructor(self)
+    PartyMembers.____super.prototype.____constructor(self, "party")
+end
+--- Includes the player through their raidN token; empty outside a raid.
+____exports.RaidMembers = __TS__Class()
+local RaidMembers = ____exports.RaidMembers
+RaidMembers.name = "RaidMembers"
+__TS__ClassExtends(RaidMembers, ____exports.GroupMembers)
+function RaidMembers.prototype.____constructor(self)
+    RaidMembers.____super.prototype.____constructor(self, "raid")
+end
+return ____exports

package/lib/datasources/Resources.d.ts

@@ -1,7 +1,7 @@
 import { ProgressSource } from "./ProgressSource";
-export declare const Unit: {
-    readonly Player: "player";
-};
+import { UnitSource } from "./UnitSource";
+import type { UnitInput } from "./UnitSource";
+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;
@@ -10,13 +10,15 @@ declare abstract class Resource extends ProgressSource {
     protected Listen(frame: wuiraNativeFrame, refresh: () => void): void;
 }
 export declare class HP extends Resource {
-    readonly unit: string;
-    constructor(unit: string);
+    readonly target: UnitSource;
+    get unit(): string;
+    constructor(unit: UnitInput);
 }
 /** Explicit mana (power type 0), even while the unit uses rage/energy. */
 export declare class Mana extends Resource {
-    readonly unit: string;
-    constructor(unit: string);
+    readonly target: UnitSource;
+    get unit(): string;
+    constructor(unit: UnitInput);
 }
 export declare const DataSources: {
     Resources: {
@@ -24,4 +26,3 @@ export declare const DataSources: {
         Mana: typeof Mana;
     };
 };
-export {};

package/lib/datasources/Resources.lua

@@ -31,11 +31,154 @@ local function __TS__ClassExtends(target, base)
         target.prototype.__tostring = base.prototype.__tostring
     end
 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 ____ProgressSource = require("datasources.ProgressSource")
 local ProgressSource = ____ProgressSource.ProgressSource
-____exports.Unit = {Player = "player"}
+local ____UnitSource = require("datasources.UnitSource")
+local resolveUnit = ____UnitSource.resolveUnit
+do
+    local ____UnitSource = require("datasources.UnitSource")
+    ____exports.Unit = ____UnitSource.Unit
+end
 --- Direct API-to-widget binding; opaque values are never compared or calculated.
 local Resource = __TS__Class()
 Resource.name = "Resource"
@@ -72,31 +215,49 @@ local HP = ____exports.HP
 HP.name = "HP"
 __TS__ClassExtends(HP, Resource)
 function HP.prototype.____constructor(self, unit)
+    local target = resolveUnit(nil, unit)
     Resource.prototype.____constructor(
         self,
-        function() return UnitHealth(unit) end,
-        function() return UnitHealthMax(unit) end,
-        function() return UnitHealthPercent(unit, true, CurveConstants.ScaleTo100) end,
-        unit,
+        function() return UnitHealth(target.Token) end,
+        function() return UnitHealthMax(target.Token) end,
+        function() return UnitHealthPercent(target.Token, true, CurveConstants.ScaleTo100) end,
+        target.Token,
         {"UNIT_HEALTH", "UNIT_MAXHEALTH"}
     )
-    self.unit = unit
+    self.target = target
 end
+__TS__SetDescriptor(
+    HP.prototype,
+    "unit",
+    {get = function(self)
+        return self.target.Token
+    end},
+    true
+)
 --- Explicit mana (power type 0), even while the unit uses rage/energy.
 ____exports.Mana = __TS__Class()
 local Mana = ____exports.Mana
 Mana.name = "Mana"
 __TS__ClassExtends(Mana, Resource)
 function Mana.prototype.____constructor(self, unit)
+    local target = resolveUnit(nil, unit)
     Resource.prototype.____constructor(
         self,
-        function() return UnitPower(unit, 0) end,
-        function() return UnitPowerMax(unit, 0) end,
-        function() return UnitPowerPercent(unit, 0, true, CurveConstants.ScaleTo100) end,
-        unit,
+        function() return UnitPower(target.Token, 0) end,
+        function() return UnitPowerMax(target.Token, 0) end,
+        function() return UnitPowerPercent(target.Token, 0, true, CurveConstants.ScaleTo100) end,
+        target.Token,
         {"UNIT_POWER_UPDATE", "UNIT_MAXPOWER", "UNIT_DISPLAYPOWER"}
     )
-    self.unit = unit
+    self.target = target
 end
+__TS__SetDescriptor(
+    Mana.prototype,
+    "unit",
+    {get = function(self)
+        return self.target.Token
+    end},
+    true
+)
 ____exports.DataSources = {Resources = {HP = ____exports.HP, Mana = ____exports.Mana}}
 return ____exports

package/lib/datasources/UnitInfo.d.ts

@@ -0,0 +1,45 @@
+import { DataSource } from "./DataSource";
+import { UnitSource } from "./UnitSource";
+import type { UnitInput } from "./UnitSource";
+export interface ClassInfo {
+    readonly id: number;
+    readonly token: string;
+    readonly name: string;
+}
+export declare class ClassSource extends DataSource<ClassInfo | undefined> {
+    private restricted;
+    readonly target: UnitSource;
+    constructor(unit: UnitInput);
+    get unit(): string;
+    protected HasSecretFields(): boolean;
+    protected GetValue(): ClassInfo | undefined;
+}
+export interface SpecializationInfo {
+    readonly id: number;
+    readonly name?: string;
+    readonly icon?: number;
+    readonly role?: string;
+    /** Native value when provided by the client; never estimated. */
+    readonly pointsSpent?: number;
+}
+export type InspectStatus = "idle" | "pending" | "ready" | "unsupported";
+/** Own data is read live; other units require an explicit inspect request. */
+export declare class SpecSource extends DataSource<readonly SpecializationInfo[] | undefined> {
+    private restricted;
+    private snapshot?;
+    private snapshotGUID?;
+    private listener?;
+    private status;
+    readonly target: UnitSource;
+    constructor(unit: UnitInput);
+    get unit(): string;
+    get Status(): InspectStatus;
+    protected HasSecretFields(): boolean;
+    protected GetValue(): readonly SpecializationInfo[] | undefined;
+    private Read;
+    /** Returns false if an inspect cannot start. No request is made from a getter. */
+    RequestInspect(): boolean;
+    private StopListening;
+    Dispose(): void;
+}
+export { SpecSource as Specializations };