wuira 0.3.2 → 0.4.0

package/lib/datasources/GroupRoster.lua

@@ -1,611 +0,0 @@
---[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
--- Lua Library inline imports
-local __TS__StringReplace
-do
-    local sub = string.sub
-    function __TS__StringReplace(source, searchValue, replaceValue)
-        local startPos, endPos = string.find(source, searchValue, nil, true)
-        if not startPos then
-            return source
-        end
-        local before = sub(source, 1, startPos - 1)
-        local replacement = type(replaceValue) == "string" and replaceValue or replaceValue(nil, searchValue, startPos - 1, source)
-        local after = sub(source, endPos + 1)
-        return (before .. replacement) .. after
-    end
-end
-
-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 __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 __TS__Unpack = table.unpack or unpack
-
-local function __TS__ArrayMap(self, callbackfn, thisArg)
-    local result = {}
-    for i = 1, #self do
-        result[i] = callbackfn(thisArg, self[i], i - 1, self)
-    end
-    return result
-end
-
-local function __TS__Number(value)
-    local valueType = type(value)
-    if valueType == "number" then
-        return value
-    elseif valueType == "string" then
-        local numberValue = tonumber(value)
-        if numberValue then
-            return numberValue
-        end
-        if value == "Infinity" then
-            return math.huge
-        end
-        if value == "-Infinity" then
-            return -math.huge
-        end
-        local stringWithoutSpaces = string.gsub(value, "%s", "")
-        if stringWithoutSpaces == "" then
-            return 0
-        end
-        return 0 / 0
-    elseif valueType == "boolean" then
-        return value and 1 or 0
-    else
-        return 0 / 0
-    end
-end
-
-local function __TS__ArraySort(self, compareFn)
-    if compareFn ~= nil then
-        table.sort(
-            self,
-            function(a, b) return compareFn(nil, a, b) < 0 end
-        )
-    else
-        table.sort(self)
-    end
-    return self
-end
-
-local function __TS__StringStartsWith(self, searchString, position)
-    if position == nil or position < 0 then
-        position = 0
-    end
-    return string.sub(self, position + 1, #searchString + position) == searchString
-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 ____GroupMembers = require("datasources.GroupMembers")
-local GroupMembers = ____GroupMembers.GroupMembers
-function ____exports.getPetUnitToken(self, unit)
-    if unit == "player" then
-        return "pet"
-    end
-    return __TS__StringReplace(
-        __TS__StringReplace(unit, "party", "partypet"),
-        "raid",
-        "raidpet"
-    )
-end
---- Small snapshots describe identity/order only; keyed rendering owns widgets and unit sources.
-____exports.GroupRoster = __TS__Class()
-local GroupRoster = ____exports.GroupRoster
-GroupRoster.name = "GroupRoster"
-__TS__ClassExtends(GroupRoster, DataSource)
-function GroupRoster.prototype.____constructor(self, scope, options)
-    if scope == nil then
-        scope = "auto"
-    end
-    if options == nil then
-        options = {}
-    end
-    DataSource.prototype.____constructor(self, {})
-    self.scope = scope
-    self.options = options
-    self.knownNames = __TS__New(Map)
-    self.snapshot = {}
-    self.restricted = false
-    self.roster = __TS__New(GroupMembers, scope)
-end
-function GroupRoster.prototype.GetValue(self)
-    self.restricted = self.roster:IsSecret()
-    if self.restricted then
-        return self.snapshot
-    end
-    local units = {__TS__Unpack(self.roster.Value)}
-    if #units == 0 and self.options.includeSelfWhenSolo then
-        units = {"player"}
-    end
-    local members = __TS__ArrayMap(
-        units,
-        function(____, unit) return self:Read(unit, false) end
-    )
-    if self.scope == "raid" then
-        __TS__ArraySort(
-            members,
-            function(____, a, b) return __TS__Number(a.group) - __TS__Number(b.group) or __TS__Number(string.sub(a.unit, 5)) - __TS__Number(string.sub(b.unit, 5)) end
-        )
-    end
-    if self.options.pets then
-        for ____, unit in ipairs(units) do
-            local pet = ____exports.getPetUnitToken(nil, unit)
-            local exists = UnitExists(pet)
-            if not issecretvalue(exists) and exists then
-                members[#members + 1] = self:Read(pet, true)
-            end
-        end
-    end
-    self.snapshot = members
-    return members
-end
-function GroupRoster.prototype.Read(self, unit, pet)
-    local rawGUID = UnitGUID(unit)
-    local ____issecretvalue_result_0
-    if issecretvalue(rawGUID) then
-        ____issecretvalue_result_0 = nil
-    else
-        ____issecretvalue_result_0 = rawGUID
-    end
-    local guid = ____issecretvalue_result_0
-    local rawName, rawRealm = UnitFullName(unit)
-    local ____temp_1
-    if issecretvalue(rawName) or issecretvalue(rawRealm) or rawName == nil then
-        ____temp_1 = nil
-    else
-        ____temp_1 = (rawName .. "-") .. (rawRealm or "")
-    end
-    local fullName = ____temp_1
-    if pet and fullName ~= nil then
-        local owner = unit == "pet" and "player" or __TS__StringReplace(
-            __TS__StringReplace(unit, "partypet", "party"),
-            "raidpet",
-            "raid"
-        )
-        local name, realm = UnitFullName(owner)
-        fullName = ((not issecretvalue(name) and not issecretvalue(realm) and name ~= nil and (name .. "-") .. (realm or "") or owner) .. "/") .. fullName
-    end
-    if guid ~= nil and fullName ~= nil then
-        self.knownNames:set(fullName, guid)
-    end
-    local ____guid_3 = guid
-    if ____guid_3 == nil then
-        local ____temp_2
-        if fullName == nil then
-            ____temp_2 = nil
-        else
-            ____temp_2 = self.knownNames:get(fullName)
-        end
-        ____guid_3 = ____temp_2
-    end
-    local identity = ____guid_3
-    local group = "1"
-    if __TS__StringStartsWith(unit, "raid") and not pet then
-        local ____, ____, subgroup = GetRaidRosterInfo(__TS__Number(string.sub(unit, 5)))
-        if not issecretvalue(subgroup) and subgroup ~= nil and subgroup >= 1 and subgroup <= 8 then
-            group = tostring(subgroup)
-        end
-    end
-    return {
-        key = identity == nil and "name:" .. (fullName or unit) or "guid:" .. identity,
-        guid = guid,
-        unit = unit,
-        pet = pet,
-        group = group
-    }
-end
-function GroupRoster.prototype.onChange(self, listener)
-    return self.roster:onChange(function() return listener(nil, self.Value) end)
-end
-function GroupRoster.prototype.Dispose(self)
-    self.roster:Dispose()
-    self.knownNames:clear()
-    self.snapshot = {}
-end
-__TS__SetDescriptor(
-    GroupRoster.prototype,
-    "Status",
-    {get = function(self)
-        return self.restricted and "restricted" or "ready"
-    end},
-    true
-)
-return ____exports

package/lib/datasources/KnownSpells.d.ts

@@ -1,33 +0,0 @@
-import { DataSource } from "./DataSource";
-export type KnownSpellsStatus = "ready" | "unavailable" | "restricted";
-export interface KnownSpell {
-    readonly id: number;
-    readonly name?: string;
-    /** Undefined when the client cannot determine whether this spell is passive. */
-    readonly isPassive?: boolean;
-}
-/** Cached learned player spellbook IDs. Native events refresh the snapshot; no polling. */
-export declare class KnownSpells extends DataSource<readonly number[]> {
-    private ids;
-    private entries;
-    private status;
-    private readonly listeners;
-    private readonly frame;
-    private disposed;
-    constructor();
-    get Status(): KnownSpellsStatus;
-    /** Detached cached metadata, with no native reads. Unreadable books return no entries. */
-    get Entries(): readonly KnownSpell[];
-    /** Whole-name glob over cached localized names. Supports * and ?, ignoring ASCII case. */
-    Filter(pattern: string): readonly KnownSpell[];
-    protected GetValue(): readonly number[];
-    protected HasSecretFields(): boolean;
-    /** Representative enum IDs match any learned rank through its localized name. */
-    Has(spell: number | string): boolean;
-    /** Resolve a representative spell ID or localized name to a learned rank. */
-    Find(spell: number | string): KnownSpell | undefined;
-    /** No initial emission; only changed, readable snapshots reach observers. */
-    onChange(listener: (spells: readonly number[]) => void): () => void;
-    private Refresh;
-    Dispose(): void;
-}