wuira 0.3.3 → 0.4.0

package/lib/datasources/GroupMembers.d.ts

@@ -1,24 +0,0 @@
-import { DataSource } from "./DataSource";
-export type GroupScope = "auto" | "party" | "raid";
-/** Fresh roster tokens, including offline members. Tokens are not persistent identities. */
-export declare class GroupMembers extends DataSource<readonly string[]> {
-    readonly scope: GroupScope;
-    private restricted;
-    private readonly listeners;
-    private frame?;
-    protected constructor(scope?: GroupScope);
-    /** Roster/connection events, with one listener frame while observed. No polling. */
-    onChange(listener: (units: readonly string[]) => void): () => void;
-    private StopListening;
-    Dispose(): void;
-    protected HasSecretFields(): boolean;
-    protected GetValue(): readonly string[];
-}
-/** Includes the player in a party; empty when solo or in a raid. */
-export declare class PartyMembers extends GroupMembers {
-    protected constructor();
-}
-/** Includes the player through their raidN token; empty outside a raid. */
-export declare class RaidMembers extends GroupMembers {
-    protected constructor();
-}

package/lib/datasources/GroupMembers.lua

@@ -1,477 +0,0 @@
---[[ 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__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 function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
-local Set
-do
-    Set = __TS__Class()
-    Set.name = "Set"
-    function Set.prototype.____constructor(self, values)
-        self[Symbol.toStringTag] = "Set"
-        self.size = 0
-        self.nextKey = {}
-        self.previousKey = {}
-        if values == nil then
-            return
-        end
-        local iterable = values
-        if iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            while true do
-                local result = iterator:next()
-                if result.done then
-                    break
-                end
-                self:add(result.value)
-            end
-        else
-            local array = values
-            for ____, value in ipairs(array) do
-                self:add(value)
-            end
-        end
-    end
-    function Set.prototype.add(self, value)
-        local isNewValue = not self:has(value)
-        if isNewValue then
-            self.size = self.size + 1
-        end
-        if self.firstKey == nil then
-            self.firstKey = value
-            self.lastKey = value
-        elseif isNewValue then
-            self.nextKey[self.lastKey] = value
-            self.previousKey[value] = self.lastKey
-            self.lastKey = value
-        end
-        return self
-    end
-    function Set.prototype.clear(self)
-        self.nextKey = {}
-        self.previousKey = {}
-        self.firstKey = nil
-        self.lastKey = nil
-        self.size = 0
-    end
-    function Set.prototype.delete(self, value)
-        local contains = self:has(value)
-        if contains then
-            self.size = self.size - 1
-            local next = self.nextKey[value]
-            local previous = self.previousKey[value]
-            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[value] = nil
-            self.previousKey[value] = nil
-        end
-        return contains
-    end
-    function Set.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(self:keys()) do
-            callback(nil, key, key, self)
-        end
-    end
-    function Set.prototype.has(self, value)
-        return self.nextKey[value] ~= nil or self.lastKey == value
-    end
-    Set.prototype[Symbol.iterator] = function(self)
-        return self:values()
-    end
-    function Set.prototype.entries(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, key}}
-            end
-        }
-    end
-    function Set.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 Set.prototype.values(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 Set.prototype.union(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            result:add(item)
-        end
-        return result
-    end
-    function Set.prototype.intersection(self, other)
-        local result = __TS__New(Set)
-        for ____, item in __TS__Iterator(self) do
-            if other:has(item) then
-                result:add(item)
-            end
-        end
-        return result
-    end
-    function Set.prototype.difference(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            result:delete(item)
-        end
-        return result
-    end
-    function Set.prototype.symmetricDifference(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            if self:has(item) then
-                result:delete(item)
-            else
-                result:add(item)
-            end
-        end
-        return result
-    end
-    function Set.prototype.isSubsetOf(self, other)
-        for ____, item in __TS__Iterator(self) do
-            if not other:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    function Set.prototype.isSupersetOf(self, other)
-        for ____, item in __TS__Iterator(other) do
-            if not self:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    function Set.prototype.isDisjointFrom(self, other)
-        for ____, item in __TS__Iterator(self) do
-            if other:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    Set[Symbol.species] = Set
-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
-local ____Source = require("datasources.Source")
-local registerSource = ____Source.registerSource
---- 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
-    self.listeners = __TS__New(Set)
-end
-function GroupMembers.prototype.onChange(self, listener)
-    self.listeners:add(listener)
-    if self.listeners.size == 1 then
-        if self.frame == nil then
-            self.frame = CreateFrame("Frame", nil, UIParent)
-        end
-        for ____, event in ipairs({
-            "GROUP_ROSTER_UPDATE",
-            "UNIT_PET",
-            "UNIT_CONNECTION",
-            "UNIT_NAME_UPDATE",
-            "PLAYER_ENTERING_WORLD"
-        }) do
-            self.frame:RegisterEvent(event)
-        end
-        self.frame:SetScript(
-            "OnEvent",
-            function()
-                local units = self:GetValue()
-                if self.restricted then
-                    return
-                end
-                for ____, callback in __TS__Iterator(self.listeners) do
-                    callback(nil, units)
-                end
-            end
-        )
-    end
-    return function()
-        self.listeners:delete(listener)
-        if self.listeners.size == 0 then
-            self:StopListening()
-        end
-    end
-end
-function GroupMembers.prototype.StopListening(self)
-    local ____opt_0 = self.frame
-    if ____opt_0 ~= nil then
-        ____opt_0:UnregisterAllEvents()
-    end
-    local ____opt_2 = self.frame
-    if ____opt_2 ~= nil then
-        ____opt_2:SetScript("OnEvent", nil)
-    end
-    local ____opt_4 = self.frame
-    if ____opt_4 ~= nil then
-        ____opt_4:Hide()
-    end
-end
-function GroupMembers.prototype.Dispose(self)
-    self.listeners:clear()
-    self:StopListening()
-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;
-(function(self)
-    registerSource(
-        nil,
-        ____exports.GroupMembers,
-        function(____, props) return __TS__New(____exports.GroupMembers, props[1]) end
-    )
-end)(GroupMembers)
---- 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;
-(function(self)
-    registerSource(
-        nil,
-        ____exports.PartyMembers,
-        function() return __TS__New(____exports.PartyMembers) end
-    )
-end)(PartyMembers)
---- 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;
-(function(self)
-    registerSource(
-        nil,
-        ____exports.RaidMembers,
-        function() return __TS__New(____exports.RaidMembers) end
-    )
-end)(RaidMembers)
-return ____exports

package/lib/datasources/GroupRoster.d.ts

@@ -1,28 +0,0 @@
-import { DataSource } from "./DataSource";
-import type { GroupScope } from "./GroupMembers";
-export interface GroupRosterMember {
-    readonly key: string;
-    readonly guid?: string;
-    readonly unit: string;
-    readonly pet: boolean;
-    readonly group: string;
-}
-export declare function getPetUnitToken(unit: string): string;
-/** Small snapshots describe identity/order only; keyed rendering owns widgets and unit sources. */
-export declare class GroupRoster extends DataSource<readonly GroupRosterMember[]> {
-    private readonly scope;
-    private readonly options;
-    private readonly roster;
-    private readonly knownNames;
-    private snapshot;
-    private restricted;
-    get Status(): "ready" | "restricted";
-    protected constructor(scope?: GroupScope, options?: {
-        pets?: boolean;
-        includeSelfWhenSolo?: boolean;
-    });
-    protected GetValue(): readonly GroupRosterMember[];
-    private Read;
-    onChange(listener: (members: readonly GroupRosterMember[]) => void): () => void;
-    Dispose(): void;
-}